poly-weaver 0.11.4 → 0.11.5

package/dist/user/host-prompt.js

@@ -1,35 +1,28 @@
-import { bold, dim, green, invert, reset, visibleLength, yellow, } from "../ansi.js";
+import { bold, dim, green, reset, visibleLength, yellow, } from "../ansi.js";
 import { AgentInterruptedError } from "../agents/runner.js";
 import { EmacsInputParser } from "./prompt.js";
-import { clipToWidth } from "./curate-prompt.js";
+import { clipToWidth, wrapToWidth } from "./curate-prompt.js";
 import { buildPlanPane } from "./plan-pane.js";
 import { renderShortcutHints } from "./shortcut-hints.js";
-import { applyTextBufferEvent, isTextBufferEvent, splitPasteToEvents, } from "../text-editing/emacs-input.js";
-import { cursorToVisual, renderWrappedLine, softWrapLine } from "../text-editing/soft-wrap.js";
+import { aliasSelectionNavEvent, isTextBufferEvent, } from "../text-editing/emacs-input.js";
 import { OffscreenController, } from "../offscreen/controller.js";
 import { AttachmentManager } from "../paste-image/attachment-manager.js";
 import { ALT_V_PASTE_IMAGE_HINT, handleBracketedPaste, handleImagePasteIntent, PASTING_IMAGE_HINT, } from "../paste-image/intents.js";
-import { ensurePersistentImagesDir } from "../paste-image/persistence.js";
-/** Maximum visible rows for the multiline feedback editor. */
-const FEEDBACK_EDITOR_MAX_ROWS = 5;
+import { buildSplitSurface, computeSplitMetrics, SPLIT_COLLAPSE_AT_COLS, } from "./split-surface.js";
+import { applyEditingBufferEvent, applyEditInsertedText, bufferFromText, emptyBuffer, finalizeEditText, renderMultilineEditor, } from "./feedback-editing.js";
+// Max rows allotted to the scrollable feedback-list block (Approve/item/+Add
+// rows only; the separator + hint are fixed chrome rendered outside this
+// budget). This same constant is both the stacked-layout scroll budget and the
+// wide-terminal split trigger.
+export const FEEDBACK_AREA_MAX_ROWS = 10;
 /** Lines of overlap when paging the plan (PageUp/PageDown). */
 const PLAN_PAGE_OVERLAP = 1;
-const ACTIVE_PREFIX = " ❯";
+const ACTIVE_SELECTOR = "❯";
 const INACTIVE_PREFIX = "  ";
 /**
- * Host-backed user-review prompt with a top-down stack layout.
- *
- * Plan on top (header rule + scrollable body), full-width dim ─ separator, and
- * a controls block (Approve + bounded feedback editor + compact hint row).
- *
- * Key handling:
- *   - ↑/↓ toggles between Approve and the editor (does NOT scroll the plan).
- *   - PageUp/PageDown/Home/End/wheel scrolls the plan.
- *   - Ctrl+D submits feedback (or accepts when on Approve).
- *   - Ctrl+C quits poly-weaver (exit code 130). When the feedback editor has
- *     typed text, the first Ctrl+C clears the buffer instead; a second Ctrl+C
- *     on an empty buffer quits.
- *   - Ctrl+] is consumed by the host's `InputRouter` for dump capture.
+ * Host-backed user-review prompt. The review controls use the same multi-item
+ * feedback model as verdict curation: add, edit, delete, then submit the list
+ * as discrete feedback items.
  */
 export class HostBackedUserPrompt {
     host;
@@ -40,23 +33,19 @@ export class HostBackedUserPrompt {
         if (!this.host.isInteractive) {
             return { accepted: true };
         }
+        const state = {
+            cursor: 1,
+            userAdded: [],
+            editing: undefined,
+            planScrollTop: 0,
+            planAtEnd: false,
+        };
+        const parser = new EmacsInputParser();
         return new Promise((resolve, reject) => {
-            const state = {
-                mode: "input",
-                lines: [""],
-                cursorLine: 0,
-                cursorCol: 0,
-                feedbackScrollTop: 0,
-                planScrollTop: 0,
-                planAtEnd: false,
-                transientHint: null,
-            };
-            const parser = new EmacsInputParser();
-            const attachments = new AttachmentManager();
             let detach;
             let offscreenController;
             let active = true;
-            let settling = false;
+            let settlingEdit = false;
             const cleanup = () => {
                 active = false;
                 offscreenController?.dispose();
@@ -72,185 +61,255 @@ export class HostBackedUserPrompt {
                 cleanup();
                 reject(err);
             };
-            const finalizeFeedbackText = async (text) => {
-                const targetDir = context.persistentDir
-                    ? await ensurePersistentImagesDir(context.persistentDir)
-                    : undefined;
-                return attachments.finalize(text, targetDir ? { targetDir } : {});
+            const submitFeedback = () => {
+                finish({ accepted: false, feedback: [...state.userAdded] });
+            };
+            const cancelEdit = () => {
+                if (settlingEdit || !state.editing)
+                    return;
+                state.editing = undefined;
+                clampCursor(state);
+            };
+            const applySubmittedEdit = (editing, text) => {
+                state.editing = undefined;
+                if (editing.target.kind === "user-edit") {
+                    const index = editing.target.index;
+                    if (text.length > 0) {
+                        state.userAdded[index] = text;
+                    }
+                    else {
+                        state.userAdded.splice(index, 1);
+                    }
+                }
+                else if (text.length > 0) {
+                    state.userAdded.push(text);
+                }
+                state.cursor = addRowCursorIndex(state);
+                clampCursor(state);
             };
-            const submitFeedback = (text) => {
-                settling = true;
-                void finalizeFeedbackText(text).then((comments) => {
-                    finish({ accepted: false, comments });
+            const submitEdit = () => {
+                const editing = state.editing;
+                if (!editing || settlingEdit)
+                    return;
+                const text = editing.buffer.lines.join("\n").trim();
+                if (editing.attachments.snapshot().length === 0) {
+                    applySubmittedEdit(editing, text);
+                    return;
+                }
+                settlingEdit = true;
+                void finalizeEditText(editing, text, context.persistentDir).then((finalText) => {
+                    if (!active || state.editing !== editing)
+                        return;
+                    applySubmittedEdit(editing, finalText);
+                    settlingEdit = false;
+                    this.host.scheduleParentUiRender();
                 }).catch((err) => {
+                    settlingEdit = false;
                     failWith(err instanceof Error ? err : new Error(String(err)));
                 });
             };
-            const applyInsertedText = (text) => {
-                if (state.mode === "approve")
-                    state.mode = "input";
-                for (const textEvent of splitPasteToEvents(text)) {
-                    applyFeedbackTextBufferEvent(state, textEvent);
-                }
+            const openUserAddEditor = () => {
+                state.cursor = addRowCursorIndex(state);
+                state.editing = {
+                    target: { kind: "user-add" },
+                    buffer: emptyBuffer(),
+                    attachments: new AttachmentManager(),
+                    transientHint: null,
+                };
             };
-            const applyPasteOutcome = (outcome) => {
-                if (!active || settling)
+            const openUserEditEditor = (index) => {
+                state.cursor = index;
+                state.editing = {
+                    target: { kind: "user-edit", index },
+                    buffer: bufferFromText(state.userAdded[index] ?? ""),
+                    attachments: new AttachmentManager(),
+                    transientHint: null,
+                };
+            };
+            const applyEditPasteOutcome = (editing, outcome) => {
+                if (!active || settlingEdit || state.editing !== editing)
                     return;
-                state.transientHint = outcome.hint ?? null;
+                editing.transientHint = outcome.hint ?? null;
                 if (outcome.inserted !== undefined)
-                    applyInsertedText(outcome.inserted);
+                    applyEditInsertedText(editing, outcome.inserted);
                 this.host.scheduleParentUiRender();
             };
-            const launchPasteIntent = (task) => {
-                void task.then(applyPasteOutcome).catch((err) => {
-                    if (!active || settling)
+            const launchEditPasteIntent = (editing, task) => {
+                void task.then((outcome) => applyEditPasteOutcome(editing, outcome)).catch((err) => {
+                    if (!active || settlingEdit || state.editing !== editing)
                         return;
-                    state.transientHint = err instanceof Error ? err.message : String(err);
+                    editing.transientHint = err instanceof Error ? err.message : String(err);
                     this.host.scheduleParentUiRender();
                 });
             };
-            const baseMode = {
-                getSurface: () => {
-                    const layout = this.host.getLayout();
-                    const cols = Math.max(20, layout.columns);
-                    const rows = Math.max(1, layout.childRows);
-                    return buildSurface(plan, context, state, cols, rows);
-                },
-                onEvents: (keys) => {
-                    const events = parser.mapKeys(keys);
-                    let dirty = false;
-                    for (const event of events) {
-                        if (settling)
-                            return true;
-                        if (state.transientHint) {
-                            state.transientHint = null;
+            const processEvents = (events) => {
+                let dirty = false;
+                let finished = false;
+                for (const rawEvent of events) {
+                    if (finished)
+                        break;
+                    const event = state.editing
+                        ? rawEvent
+                        : aliasSelectionNavEvent(rawEvent);
+                    if (state.editing) {
+                        if (settlingEdit) {
+                            dirty = true;
+                            continue;
+                        }
+                        if (state.editing.transientHint) {
+                            state.editing.transientHint = null;
                             dirty = true;
                         }
                         if (event.type === "paste") {
-                            launchPasteIntent(handleBracketedPaste(event.content, attachments));
+                            const editing = state.editing;
+                            launchEditPasteIntent(editing, handleBracketedPaste(event.content, editing.attachments));
                             continue;
                         }
                         if (event.type === "image-paste") {
-                            launchPasteIntent(handleImagePasteIntent(attachments, () => {
-                                if (!active || settling)
+                            const editing = state.editing;
+                            launchEditPasteIntent(editing, handleImagePasteIntent(editing.attachments, () => {
+                                if (!active || settlingEdit || state.editing !== editing)
                                     return;
-                                state.transientHint = PASTING_IMAGE_HINT;
+                                editing.transientHint = PASTING_IMAGE_HINT;
                                 this.host.scheduleParentUiRender();
                             }));
                             continue;
                         }
-                        if (event.type === "ctrl-c") {
-                            const bufferEmpty = state.lines.length === 1 && state.lines[0] === "";
-                            if (bufferEmpty) {
-                                failWith(new AgentInterruptedError("Interrupted"));
-                                return true;
-                            }
-                            state.lines = [""];
-                            state.cursorLine = 0;
-                            state.cursorCol = 0;
-                            state.feedbackScrollTop = 0;
-                            state.mode = "input";
+                        if (event.type === "ctrl-c" || event.type === "escape") {
+                            cancelEdit();
                             dirty = true;
                             continue;
                         }
-                        if (event.type === "ctrl-d") {
-                            if (state.mode === "approve") {
-                                finish({ accepted: true });
-                                return true;
-                            }
-                            const text = state.lines.join("\n").trim();
-                            if (text.length > 0) {
-                                submitFeedback(text);
-                                return true;
-                            }
-                            continue;
-                        }
-                        if (event.type === "enter") {
-                            if (state.mode === "approve") {
-                                finish({ accepted: true });
-                                return true;
-                            }
-                            dirty = applyFeedbackTextBufferEvent(state, { type: "newline" }) || dirty;
+                        if (event.type === "ctrl-d" || event.type === "enter") {
+                            submitEdit();
+                            dirty = true;
                             continue;
                         }
                         if (event.type === "ctrl-j") {
-                            if (state.mode === "input") {
-                                dirty = applyFeedbackTextBufferEvent(state, { type: "newline" }) || dirty;
-                            }
+                            dirty = applyEditingBufferEvent(state.editing, { type: "newline" }) || dirty;
                             continue;
                         }
                         if (event.type === "arrow") {
-                            if (event.direction === "up" && state.mode === "input") {
-                                state.mode = "approve";
-                                dirty = true;
-                            }
-                            else if (event.direction === "down" && state.mode === "approve") {
-                                state.mode = "input";
-                                dirty = true;
-                            }
-                            else if (state.mode === "input" &&
-                                (event.direction === "left" || event.direction === "right")) {
-                                dirty = applyFeedbackTextBufferEvent(state, {
+                            if (event.direction === "left" || event.direction === "right") {
+                                dirty = applyEditingBufferEvent(state.editing, {
                                     type: event.direction === "left" ? "ctrl-b" : "ctrl-f",
                                 }) || dirty;
                             }
                             continue;
                         }
-                        if (event.type === "scroll-page") {
-                            const { planHeight, planLines } = planMetrics(plan, context, state, this.host);
-                            const step = Math.max(1, planHeight - PLAN_PAGE_OVERLAP);
-                            const max = Math.max(0, planLines - planHeight);
-                            if (event.direction === "up") {
-                                state.planScrollTop = Math.max(0, state.planScrollTop - step);
-                            }
-                            else {
-                                state.planScrollTop = Math.min(max, state.planScrollTop + step);
-                            }
-                            state.planAtEnd = state.planScrollTop >= max;
-                            dirty = true;
+                        if (isTextBufferEvent(event)) {
+                            dirty = applyEditingBufferEvent(state.editing, event) || dirty;
                             continue;
                         }
-                        if (event.type === "scroll-home") {
-                            state.planScrollTop = 0;
-                            state.planAtEnd = false;
+                        continue;
+                    }
+                    if (event.type === "ctrl-c") {
+                        failWith(new AgentInterruptedError("Interrupted"));
+                        finished = true;
+                        continue;
+                    }
+                    if (event.type === "ctrl-d") {
+                        if (state.userAdded.length === 0) {
+                            finish({ accepted: true });
+                        }
+                        else {
+                            submitFeedback();
+                        }
+                        finished = true;
+                        continue;
+                    }
+                    if (event.type === "arrow") {
+                        if (event.direction === "up" || event.direction === "down") {
+                            const total = navigableRows(state).length;
+                            state.cursor = event.direction === "up"
+                                ? (state.cursor - 1 + total) % total
+                                : (state.cursor + 1) % total;
                             dirty = true;
-                            continue;
                         }
-                        if (event.type === "scroll-end") {
-                            const { planHeight, planLines } = planMetrics(plan, context, state, this.host);
-                            state.planScrollTop = Math.max(0, planLines - planHeight);
-                            state.planAtEnd = true;
+                        continue;
+                    }
+                    if (event.type === "scroll-page") {
+                        const { planHeight, planLines } = planMetrics(plan, context, state, this.host);
+                        const step = Math.max(1, planHeight - PLAN_PAGE_OVERLAP);
+                        const max = Math.max(0, planLines - planHeight);
+                        if (event.direction === "up") {
+                            state.planScrollTop = Math.max(0, state.planScrollTop - step);
+                        }
+                        else {
+                            state.planScrollTop = Math.min(max, state.planScrollTop + step);
+                        }
+                        state.planAtEnd = state.planScrollTop >= max;
+                        dirty = true;
+                        continue;
+                    }
+                    if (event.type === "scroll-home") {
+                        state.planScrollTop = 0;
+                        state.planAtEnd = false;
+                        dirty = true;
+                        continue;
+                    }
+                    if (event.type === "scroll-end") {
+                        const { planHeight, planLines } = planMetrics(plan, context, state, this.host);
+                        state.planScrollTop = Math.max(0, planLines - planHeight);
+                        state.planAtEnd = true;
+                        dirty = true;
+                        continue;
+                    }
+                    if (event.type === "scroll-lines") {
+                        const { planHeight, planLines } = planMetrics(plan, context, state, this.host);
+                        const max = Math.max(0, planLines - planHeight);
+                        state.planScrollTop = Math.min(max, Math.max(0, state.planScrollTop + event.delta));
+                        state.planAtEnd = state.planScrollTop >= max;
+                        dirty = true;
+                        continue;
+                    }
+                    if (event.type === "enter") {
+                        const row = currentRow(state);
+                        if (row.kind === "approve") {
+                            finish({ accepted: true });
+                            finished = true;
+                        }
+                        else if (row.kind === "item") {
+                            openUserEditEditor(row.index);
                             dirty = true;
-                            continue;
                         }
-                        if (event.type === "scroll-lines") {
-                            const { planHeight, planLines } = planMetrics(plan, context, state, this.host);
-                            const max = Math.max(0, planLines - planHeight);
-                            state.planScrollTop = Math.min(max, Math.max(0, state.planScrollTop + event.delta));
-                            state.planAtEnd = state.planScrollTop >= max;
+                        else {
+                            openUserAddEditor();
+                            dirty = true;
+                        }
+                        continue;
+                    }
+                    if (event.type === "insert") {
+                        const ch = event.text.toLowerCase();
+                        if (ch === "a") {
+                            openUserAddEditor();
                             dirty = true;
                             continue;
                         }
-                        if (isTextBufferEvent(event)) {
-                            if (state.mode === "approve") {
-                                if (event.type === "insert") {
-                                    state.mode = "input";
-                                    applyFeedbackTextBufferEvent(state, event);
-                                    dirty = true;
-                                }
-                                else if (event.type === "backspace") {
-                                    state.mode = "input";
-                                    dirty = true;
-                                }
-                                continue;
+                        if (ch === "d") {
+                            const row = currentRow(state);
+                            if (row.kind === "item") {
+                                state.userAdded.splice(row.index, 1);
+                                clampCursor(state);
+                                state.cursor = addRowCursorIndex(state);
+                                dirty = true;
                             }
-                            dirty = applyFeedbackTextBufferEvent(state, event) || dirty;
-                            continue;
                         }
-                        // tab/escape/dump ignored — dump is consumed by the host router.
                     }
-                    if (dirty)
-                        this.host.scheduleParentUiRender();
+                }
+                if (dirty && !finished)
+                    this.host.scheduleParentUiRender();
+                return finished;
+            };
+            const baseMode = {
+                getSurface: () => {
+                    const layout = this.host.getLayout();
+                    const cols = Math.max(20, layout.columns);
+                    const rows = Math.max(1, layout.childRows);
+                    return buildSurface(plan, context, state, cols, rows);
+                },
+                onEvents: (keys) => {
+                    processEvents(parser.mapKeys(keys));
                     return true;
                 },
             };
@@ -263,161 +322,196 @@ export class HostBackedUserPrompt {
         });
     }
 }
-function normalizeFeedbackCursor(state) {
-    if (state.lines.length === 0)
-        state.lines = [""];
-    state.cursorLine = Math.max(0, Math.min(state.cursorLine, state.lines.length - 1));
-    state.cursorCol = Math.max(0, Math.min(state.cursorCol, state.lines[state.cursorLine].length));
+function navigableRows(state) {
+    if (state.userAdded.length === 0) {
+        return [{ kind: "approve" }, { kind: "add" }];
+    }
+    return [
+        ...state.userAdded.map((_, index) => ({ kind: "item", index })),
+        { kind: "add" },
+    ];
+}
+function currentRow(state) {
+    clampCursor(state);
+    return navigableRows(state)[state.cursor] ?? { kind: "approve" };
 }
-function applyFeedbackTextBufferEvent(state, event) {
-    normalizeFeedbackCursor(state);
-    const buffer = {
-        lines: state.lines,
-        cursorRow: state.cursorLine,
-        cursorCol: state.cursorCol,
-    };
-    const changed = applyTextBufferEvent(buffer, event);
-    state.lines = buffer.lines;
-    state.cursorLine = buffer.cursorRow;
-    state.cursorCol = buffer.cursorCol;
-    normalizeFeedbackCursor(state);
-    return changed;
+function addRowCursorIndex(state) {
+    return state.userAdded.length === 0 ? 1 : state.userAdded.length;
 }
-/**
- * Build the natural-height controls block (no padding):
- *   ❯ Approve  (Enter)        — when state.mode === "approve"
- *   _                         — feedback editor (1..5 rows; placeholder when empty)
- *   Ctrl+D Submit             — hint, only when input mode and editor non-empty
- *
- * Returns its natural height (1..7 rows). Cursor is pane-local.
- */
-function buildControlsBlock(state, width, offscreenHint) {
-    const activePrefixWidth = visibleLength(ACTIVE_PREFIX);
-    const inactivePrefixWidth = visibleLength(INACTIVE_PREFIX);
-    const bodyWidth = Math.max(1, width - inactivePrefixWidth);
-    const approveRow = state.mode === "approve"
-        ? `${ACTIVE_PREFIX}${bold}${green}Approve  (Enter)${reset}`
-        : `${INACTIVE_PREFIX}${dim}Approve${reset}`;
-    const showPlaceholder = state.lines.length === 1 && state.lines[0].length === 0;
-    const hasFeedback = state.lines.some((line) => line.length > 0);
-    const visualRows = [];
-    let cursorVisualRow = 0;
-    let cursorVisCol = 0;
-    if (!showPlaceholder) {
-        const cursorLine = Math.min(Math.max(0, state.cursorLine), state.lines.length - 1);
-        for (let logIdx = 0; logIdx < state.lines.length; logIdx++) {
-            const line = state.lines[logIdx] ?? "";
-            const segments = softWrapLine(line, bodyWidth);
-            if (logIdx < cursorLine) {
-                cursorVisualRow += segments.length;
-            }
-            else if (logIdx === cursorLine) {
-                const cursor = cursorToVisual(segments, state.cursorCol, line.length, bodyWidth);
-                cursorVisualRow += cursor.subRow;
-                cursorVisCol = cursor.visCol;
-            }
-            const rendered = renderWrappedLine(line, bodyWidth, state.mode === "input" && logIdx === cursorLine ? state.cursorCol : null);
-            for (let subRow = 0; subRow < rendered.length; subRow++) {
-                visualRows.push({ logIdx, subRow, body: rendered[subRow] });
-            }
-        }
-    }
-    const unboundedEditor = showPlaceholder ? 1 : visualRows.length;
-    const editorHeight = Math.min(FEEDBACK_EDITOR_MAX_ROWS, Math.max(1, unboundedEditor));
-    if (showPlaceholder) {
-        state.feedbackScrollTop = 0;
+function clampCursor(state) {
+    const max = Math.max(0, navigableRows(state).length - 1);
+    state.cursor = Math.max(0, Math.min(state.cursor, max));
+}
+// Natural (unbounded) height of the feedback-list block at the given render
+// width - the dim/active Approve row + every item row (incl. inline editor) +
+// the +Add row. Excludes the separator/hint chrome. Used by `planMetrics` to
+// size the plan area on scroll events.
+function measureFeedbackListRows(state, width) {
+    return buildFeedbackListRows(state, width).lines.length;
+}
+function buildFeedbackListRows(state, width) {
+    clampCursor(state);
+    const lines = [];
+    const rowStarts = [];
+    const rowEnds = [];
+    let editorRow;
+    let editorCol = 0;
+    if (state.userAdded.length === 0) {
+        const active = state.cursor === 0;
+        rowStarts[0] = lines.length;
+        lines.push(clipToWidth(active
+            ? `${ACTIVE_SELECTOR}${bold}${green}✓ Approve  (Enter)${reset}`
+            : ` ${dim}✓ Approve${reset}`, width));
+        rowEnds[0] = lines.length;
     }
     else {
-        if (cursorVisualRow < state.feedbackScrollTop) {
-            state.feedbackScrollTop = cursorVisualRow;
+        lines.push(clipToWidth(` ${dim}✓ Approve${reset}`, width));
+    }
+    for (let i = 0; i < state.userAdded.length; i++) {
+        const isCursor = state.cursor === i;
+        const leadChar = isCursor ? ACTIVE_SELECTOR : " ";
+        const head = `${leadChar} ${i + 1}. `;
+        const headWidth = visibleLength(head);
+        const indent = " ".repeat(headWidth);
+        const avail = Math.max(1, width - headWidth);
+        rowStarts[i] = lines.length;
+        if (state.editing?.target.kind === "user-edit" &&
+            state.editing.target.index === i) {
+            const renderedEditor = renderMultilineEditor(state.editing.buffer, width, head, indent);
+            editorRow = lines.length + renderedEditor.cursorRowOffset;
+            editorCol = renderedEditor.cursorCol;
+            lines.push(...renderedEditor.lines);
         }
-        else if (cursorVisualRow >= state.feedbackScrollTop + editorHeight) {
-            state.feedbackScrollTop = cursorVisualRow - editorHeight + 1;
+        else {
+            const wrapped = wrapToWidth(state.userAdded[i] ?? "", avail);
+            lines.push(clipToWidth(`${head}${wrapped[0] ?? ""}`, width));
+            for (let j = 1; j < wrapped.length; j++) {
+                lines.push(clipToWidth(`${indent}${wrapped[j]}`, width));
+            }
         }
-        const maxScroll = Math.max(0, visualRows.length - editorHeight);
-        if (state.feedbackScrollTop > maxScroll)
-            state.feedbackScrollTop = maxScroll;
-        if (state.feedbackScrollTop < 0)
-            state.feedbackScrollTop = 0;
+        rowEnds[i] = lines.length;
     }
-    const placeholder = "Type feedback";
-    const editorBody = [];
-    if (showPlaceholder) {
-        let first;
-        if (state.mode === "input") {
-            const head = placeholder[0] ?? " ";
-            const tail = placeholder.slice(1);
-            first = `${ACTIVE_PREFIX}${dim}${invert}${head}${reset}${dim}${tail}${reset}`;
+    {
+        const rowIndex = addRowCursorIndex(state);
+        const isCursor = state.cursor === rowIndex;
+        rowStarts[rowIndex] = lines.length;
+        if (state.editing?.target.kind === "user-add") {
+            const head = `${ACTIVE_SELECTOR} ${state.userAdded.length + 1}. `;
+            const headWidth = visibleLength(head);
+            const renderedEditor = renderMultilineEditor(state.editing.buffer, width, head, " ".repeat(headWidth));
+            editorRow = lines.length + renderedEditor.cursorRowOffset;
+            editorCol = renderedEditor.cursorCol;
+            lines.push(...renderedEditor.lines);
         }
         else {
-            first = `${INACTIVE_PREFIX}${dim}${placeholder}${reset}`;
+            lines.push(clipToWidth(isCursor
+                ? `${ACTIVE_SELECTOR}${bold}${green}+ Add feedback  (Enter)${reset}`
+                : ` ${dim}+ Add feedback${reset}`, width));
         }
-        editorBody.push(first);
-        while (editorBody.length < editorHeight)
-            editorBody.push("");
+        rowEnds[rowIndex] = lines.length;
     }
-    else {
-        for (let i = 0; i < editorHeight; i++) {
-            const visual = visualRows[state.feedbackScrollTop + i];
-            if (!visual) {
-                editorBody.push("");
-                continue;
+    return {
+        lines,
+        rowStarts,
+        rowEnds,
+        editorRow,
+        editorCol,
+    };
+}
+function buildFeedbackPane(state, rendered, width, listRows, hintTokens) {
+    const scrollRows = Math.max(0, listRows);
+    const activeStart = rendered.rowStarts[state.cursor] ?? 0;
+    const activeEndExclusive = rendered.rowEnds[state.cursor] ?? rendered.lines.length;
+    let scrollTop = 0;
+    const total = rendered.lines.length;
+    if (scrollRows > 0 && total > scrollRows) {
+        scrollTop = activeStart;
+        if (activeEndExclusive - scrollTop < scrollRows) {
+            scrollTop = Math.max(0, total - scrollRows);
+            if (scrollTop > activeStart)
+                scrollTop = activeStart;
+        }
+        if (rendered.editorRow !== undefined) {
+            if (rendered.editorRow < scrollTop)
+                scrollTop = rendered.editorRow;
+            if (rendered.editorRow >= scrollTop + scrollRows) {
+                scrollTop = rendered.editorRow - scrollRows + 1;
             }
-            const isFirstUnderlying = visual.logIdx === 0 && visual.subRow === 0;
-            const prefix = isFirstUnderlying && state.mode === "input"
-                ? ACTIVE_PREFIX
-                : INACTIVE_PREFIX;
-            editorBody.push(`${prefix}${visual.body}`);
         }
+        if (scrollTop < 0)
+            scrollTop = 0;
+        if (scrollTop + scrollRows > total)
+            scrollTop = total - scrollRows;
     }
-    const tokens = [];
-    if (state.mode === "input")
-        tokens.push("Ctrl+J Newline");
-    if (hasFeedback)
-        tokens.push("Ctrl+D Submit");
-    if (offscreenHint)
-        tokens.push(offscreenHint);
-    tokens.push(ALT_V_PASTE_IMAGE_HINT);
-    if (state.transientHint)
-        tokens.push(`${yellow}${state.transientHint}${reset}`);
-    const lines = [
-        approveRow,
-        ...editorBody,
-        `${dim}${"─".repeat(width)}${reset}`,
-        `${INACTIVE_PREFIX}${renderShortcutHints(tokens)}`,
-    ];
-    const approveRowInBlock = 0;
-    const editorStart = 1;
+    const listLines = scrollRows === 0
+        ? []
+        : rendered.lines.slice(scrollTop, scrollTop + scrollRows);
+    while (listLines.length < scrollRows)
+        listLines.push("");
     let cursorRow;
     let cursorCol;
-    if (state.mode === "approve") {
-        cursorRow = approveRowInBlock;
-        cursorCol = activePrefixWidth;
-    }
-    else if (showPlaceholder) {
-        cursorRow = editorStart;
-        cursorCol = activePrefixWidth;
+    if (rendered.editorRow !== undefined) {
+        cursorRow = rendered.editorRow - scrollTop;
+        cursorCol = rendered.editorCol;
     }
     else {
-        const offset = Math.min(Math.max(0, cursorVisualRow - state.feedbackScrollTop), editorHeight - 1);
-        cursorRow = editorStart + offset;
-        const cursorLine = Math.min(Math.max(0, state.cursorLine), state.lines.length - 1);
-        const isFirstUnderlying = cursorLine === 0 && cursorVisualRow === 0;
-        const prefixLen = isFirstUnderlying ? activePrefixWidth : inactivePrefixWidth;
-        cursorCol = prefixLen + cursorVisCol;
+        cursorRow = activeStart - scrollTop;
+        cursorCol = currentRow(state).kind === "approve" ? visibleLength(ACTIVE_SELECTOR) : 0;
     }
-    if (cursorRow < 0)
+    if (scrollRows === 0) {
         cursorRow = 0;
-    if (cursorCol < 0)
         cursorCol = 0;
+    }
+    else {
+        if (cursorRow < 0)
+            cursorRow = 0;
+        if (cursorRow >= scrollRows)
+            cursorRow = scrollRows - 1;
+        if (cursorCol < 0)
+            cursorCol = 0;
+        if (cursorCol >= width)
+            cursorCol = Math.max(0, width - 1);
+    }
+    const lines = [
+        ...listLines,
+        `${dim}${"─".repeat(width)}${reset}`,
+        `${INACTIVE_PREFIX}${renderShortcutHints(hintTokens)}`,
+    ];
     return {
-        lines: lines.map((l) => clipToWidth(l, width)),
+        lines: lines.map((line) => clipToWidth(line, width)),
         cursor: { row: cursorRow, col: cursorCol },
     };
 }
+function promptHelpTokens(state, offscreenHint) {
+    if (state.editing) {
+        const tokens = ["Ctrl+J Newline", "Enter Submit", "Esc Cancel", ALT_V_PASTE_IMAGE_HINT];
+        if (state.editing.transientHint) {
+            tokens.push(`${yellow}${state.editing.transientHint}${reset}`);
+        }
+        if (offscreenHint)
+            tokens.push(offscreenHint);
+        return tokens;
+    }
+    const row = currentRow(state);
+    const tokens = [];
+    if (row.kind === "item") {
+        tokens.push("Enter Edit", "D Delete", "A Add");
+    }
+    else if (row.kind === "add") {
+        tokens.push("Enter/A Add");
+    }
+    else {
+        tokens.push("Enter Approve", "A Add");
+    }
+    tokens.push(state.userAdded.length === 0 ? "Ctrl+D Approve" : "Ctrl+D Submit");
+    tokens.push("Ctrl+C Quit");
+    if (offscreenHint)
+        tokens.push(offscreenHint);
+    return tokens;
+}
 /**
- * Compute the plan area's available height given total `rows` and the natural
- * controls block height. Reserves 1 row for the dim ─ separator.
+ * Compute the plan area's available height given total `rows` and the controls
+ * block height. Reserves 1 row for the dim separator between plan and controls.
  */
 function computePlanRows(controlsHeight, rows) {
     return Math.max(1, rows - controlsHeight - 1);
@@ -426,8 +520,6 @@ function buildPlanLines(plan, context, state, width, planRows) {
     const pane = buildPlanPane(plan, context.phaseLabel, width, context.artifactKind ?? "plan");
     const total = pane.lines.length;
     const maxScroll = Math.max(0, total - planRows);
-    // Re-pin to the new bottom when the user last scrolled to End and the plan
-    // window has since shrunk (e.g. the controls block grew while typing).
     if (state.planAtEnd)
         state.planScrollTop = maxScroll;
     if (state.planScrollTop > maxScroll)
@@ -438,12 +530,24 @@ function buildPlanLines(plan, context, state, width, planRows) {
     while (sliced.length < planRows)
         sliced.push("");
     return {
-        lines: sliced.map((l) => clipToWidth(l, width)),
+        lines: sliced.map((line) => clipToWidth(line, width)),
         total,
     };
 }
 function buildSurface(plan, context, state, cols, rows) {
-    const controls = buildControlsBlock(state, cols, primaryOffscreenHint(context));
+    const split = computeSplitMetrics({ cols, rows, collapseAt: SPLIT_COLLAPSE_AT_COLS });
+    const natural = buildFeedbackListRows(state, cols);
+    const naturalRows = natural.lines.length;
+    const offscreenHint = primaryOffscreenHint(context);
+    const hintTokens = promptHelpTokens(state, offscreenHint);
+    if (!split.collapsed && naturalRows > FEEDBACK_AREA_MAX_ROWS) {
+        const leftRender = buildFeedbackListRows(state, split.leftWidth);
+        const left = buildFeedbackPane(state, leftRender, split.leftWidth, Math.min(leftRender.lines.length, Math.max(0, rows - 2)), hintTokens);
+        const { lines: rightLines } = buildPlanLines(plan, context, state, split.rightWidth, rows);
+        return buildSplitSurface({ lines: left.lines, cursor: left.cursor }, { lines: rightLines }, { cols, rows, collapseAt: SPLIT_COLLAPSE_AT_COLS }, "left");
+    }
+    const listRows = Math.min(naturalRows, FEEDBACK_AREA_MAX_ROWS);
+    const controls = buildFeedbackPane(state, natural, cols, listRows, hintTokens);
     const planRows = computePlanRows(controls.lines.length, rows);
     const { lines: planLines } = buildPlanLines(plan, context, state, cols, planRows);
     const separator = `${dim}${"─".repeat(cols)}${reset}`;
@@ -452,16 +556,11 @@ function buildSurface(plan, context, state, cols, rows) {
         separator,
         ...controls.lines,
     ];
-    // Pad / clip to exactly `rows` rows. The plan area is the only flex region;
-    // controls + separator + margins remain anchored to the bottom.
     while (composed.length < rows)
         composed.push("");
     if (composed.length > rows) {
-        // Clip from the top of the plan area; never clip controls.
         composed.splice(0, composed.length - rows);
     }
-    // Cursor row sits in the controls block: planRows + 1 (separator) +
-    // controls.cursor.row.
     let cursorRow = planRows + 1 + controls.cursor.row;
     if (cursorRow < 0)
         cursorRow = 0;
@@ -476,8 +575,14 @@ function planMetrics(plan, context, state, host) {
     const layout = host.getLayout();
     const cols = Math.max(20, layout.columns);
     const rows = Math.max(1, layout.childRows);
-    const controls = buildControlsBlock(state, cols, primaryOffscreenHint(context));
-    const planHeight = computePlanRows(controls.lines.length, rows);
+    const split = computeSplitMetrics({ cols, rows, collapseAt: SPLIT_COLLAPSE_AT_COLS });
+    const naturalRows = measureFeedbackListRows(state, cols);
+    if (!split.collapsed && naturalRows > FEEDBACK_AREA_MAX_ROWS) {
+        const pane = buildPlanPane(plan, context.phaseLabel, split.rightWidth, context.artifactKind ?? "plan");
+        return { planHeight: rows, planLines: pane.lines.length };
+    }
+    const controlsHeight = Math.min(naturalRows, FEEDBACK_AREA_MAX_ROWS) + 2;
+    const planHeight = computePlanRows(controlsHeight, rows);
     const pane = buildPlanPane(plan, context.phaseLabel, cols, context.artifactKind ?? "plan");
     return { planHeight, planLines: pane.lines.length };
 }