@crouton-kit/humanloop 0.3.21 → 0.3.23

package/dist/tui/render.js

@@ -1,157 +1,18 @@
-import stringWidth from 'string-width';
 import { renderMarkdown } from '../render/termrender.js';
-// ── ANSI helpers ─────────────────────────────────────────────────────────────
-const ESC = '\x1b[';
-const RESET = `${ESC}0m`;
-const BOLD = `${ESC}1m`;
-const DIM = `${ESC}2m`;
-const ITALIC = `${ESC}3m`;
-const GREEN = `${ESC}32m`;
-const YELLOW = `${ESC}33m`;
-const CYAN = `${ESC}36m`;
-const CONTROL_CHARS_RE = /\x1b\[[0-9;?]*[a-zA-Z]|\x1b[@-_]|[\x00-\x08\x0B\x0E-\x1F\x7F-\x9F]/g;
-export function sanitize(text) {
-    if (typeof text !== 'string')
-        return '';
-    return text.replace(CONTROL_CHARS_RE, '');
-}
-function singleLine(text) {
-    return sanitize(text).replace(/\s+/g, ' ').trim();
-}
-function truncate(text, maxWidth) {
-    if (maxWidth < 1)
-        return '';
-    if (stringWidth(text) <= maxWidth)
-        return text;
-    const chars = [...text];
-    let w = 0;
-    let out = '';
-    for (const ch of chars) {
-        const cw = stringWidth(ch);
-        if (w + cw + 1 > maxWidth)
-            break;
-        out += ch;
-        w += cw;
-    }
-    return out + '…';
-}
-function padRight(text, width) {
-    const w = stringWidth(text);
-    if (w >= width)
-        return text;
-    return text + ' '.repeat(width - w);
-}
-function hline(width, char = '─') {
-    if (width < 1)
-        return '';
-    return char.repeat(width);
-}
-function wrap(text, maxWidth) {
-    if (maxWidth < 1)
-        return [text];
-    const out = [];
-    const paragraphs = text.split('\n');
-    for (let p = 0; p < paragraphs.length; p++) {
-        const para = paragraphs[p];
-        if (para === '') {
-            out.push('');
-            continue;
-        }
-        const words = para.split(/[ \t]+/).filter(Boolean);
-        let current = '';
-        for (let word of words) {
-            while (stringWidth(word) > maxWidth) {
-                if (current) {
-                    out.push(current);
-                    current = '';
-                }
-                const piece = sliceByWidth(word, maxWidth);
-                out.push(piece);
-                word = word.slice(piece.length);
-            }
-            const candidate = current ? `${current} ${word}` : word;
-            if (stringWidth(candidate) <= maxWidth) {
-                current = candidate;
-            }
-            else {
-                if (current)
-                    out.push(current);
-                current = word;
-            }
-        }
-        if (current)
-            out.push(current);
-    }
-    return out.length > 0 ? out : [''];
-}
-function sliceByWidth(s, maxWidth) {
-    let w = 0;
-    let out = '';
-    for (const ch of s) {
-        const cw = stringWidth(ch);
-        if (w + cw > maxWidth)
-            break;
-        out += ch;
-        w += cw;
-    }
-    if (out === '' && s.length > 0)
-        out = [...s][0];
-    return out;
-}
-function hardWrap(text, maxWidth) {
-    if (maxWidth < 1)
-        return [text];
-    const segments = text.split('\n');
-    const out = [];
-    for (const seg of segments) {
-        if (seg.length === 0) {
-            out.push('');
-            continue;
-        }
-        let current = '';
-        let currentW = 0;
-        for (const ch of [...seg]) {
-            const cw = stringWidth(ch);
-            if (currentW + cw > maxWidth) {
-                out.push(current);
-                current = ch;
-                currentW = cw;
-            }
-            else {
-                current += ch;
-                currentW += cw;
-            }
-        }
-        out.push(current);
-    }
-    return out;
-}
-// ── Horizontal centering ─────────────────────────────────────────────────────
-/**
- * Pad each non-empty line with leading spaces to horizontally center the
- * `contentWidth`-wide block within `cols`. Wide terminals (dashboard, full
- * screen) get visual breathing room; narrow panes (split tmux pane next to a
- * spawning agent) skip centering because there's nothing to center.
- *
- * Empty lines stay empty so frame diffing can keep them as cheap no-ops.
- */
-function centerHorizontal(lines, cols, contentWidth) {
-    const extraPad = Math.max(0, Math.floor((cols - contentWidth) / 2));
-    if (extraPad === 0)
-        return lines;
-    const pad = ' '.repeat(extraPad);
-    return lines.map((line) => (line === '' ? '' : pad + line));
-}
+import { ESC, RESET, BOLD, DIM, ITALIC, GREEN, YELLOW, CYAN, REVERSE, sanitize, singleLine, truncate, hline, wrap, hardWrap, centerHorizontal, clipLine, } from './ansi.js';
 // ── Frame buffer ─────────────────────────────────────────────────────────────
-export function diffFrame(prevFrame, nextLines, rows) {
+export function diffFrame(prevFrame, nextLines, rows, cols) {
+    const clipped = cols !== undefined
+        ? nextLines.map((l) => clipLine(l, cols))
+        : nextLines;
     const writes = [];
     for (let i = 0; i < rows; i++) {
-        const line = i < nextLines.length ? nextLines[i] : '';
+        const line = i < clipped.length ? clipped[i] : '';
         if (prevFrame[i] !== line) {
             writes.push(`${ESC}${i + 1};1H${ESC}2K${line}`);
         }
     }
-    return { writes, nextPrevFrame: [...nextLines] };
+    return { writes, nextPrevFrame: [...clipped] };
 }
 // ── Renderers ────────────────────────────────────────────────────────────────
 export function renderOverview(state, cols, rows) {
@@ -221,7 +82,29 @@ export function renderOverview(state, cols, rows) {
     const centered = centerHorizontal(lines.slice(0, rows), cols, Math.min(cols, 60) + 2);
     return centered;
 }
-export function renderItemReview(state, cols, rows) {
+/**
+ * Render a (possibly multiline) input buffer with a visible cursor at
+ * `cursor` (a code-point index). A private-use sentinel is inserted at the
+ * cursor position, the result is hard-wrapped (so `\n` and width-wrapping
+ * behave exactly as they would without a cursor), then the sentinel is
+ * swapped for a reverse-video block on whichever wrapped line it landed on.
+ * `stringWidth('\uE000') === 1`, so it occupies exactly one column and never
+ * throws off the wrap math.
+ */
+export function renderInputBuffer(buffer, cursor, maxWidth) {
+    const chars = [...buffer];
+    const at = Math.max(0, Math.min(cursor, chars.length));
+    const withCaret = [...chars.slice(0, at), '\uE000', ...chars.slice(at)].join('');
+    const wrapped = hardWrap(withCaret, maxWidth);
+    return wrapped.map((line) => (line.includes('\uE000') ? line.replace('\uE000', `${REVERSE} ${RESET}`) : line));
+}
+/**
+ * Build the item-review frame parts (pre/body/post) and derive the body's
+ * scroll bounds. Pure: reads state, mutates nothing. Both `renderItemReview`
+ * and the pre-render `clampItemReviewScroll` go through this, so the layout
+ * math has a single source of truth.
+ */
+function buildItemReviewLayout(state, cols, rows) {
     const interaction = state.interactions[state.currentIndex];
     const visual = state.visuals.get(interaction.id);
     const response = state.responses.get(interaction.id);
@@ -301,23 +184,23 @@ export function renderItemReview(state, cols, rows) {
                     ? opts.find((o) => o.id === attachedId)
                     : undefined;
                 const valueText = attached !== undefined
-                    ? `${CYAN}${singleLine(attached.label)}${RESET}`
+                    ? `${CYAN}${truncate(singleLine(attached.label), Math.max(10, maxW - 28))}${RESET}`
                     : `${DIM}none (overall)${RESET}`;
                 attachedLine = `  ${DIM}attached:${RESET} ${valueText}  ${DIM}[tab to cycle]${RESET}`;
             }
         }
-        postLines.push(`  ${YELLOW}${label}:${RESET}`);
-        const bufLines = hardWrap(state.inputMode.buffer, maxW - 1);
-        for (let i = 0; i < bufLines.length; i++) {
-            const isLast = i === bufLines.length - 1;
-            postLines.push(`  ${bufLines[i]}${isLast ? '█' : ''}`);
+        for (const labelLine of wrap(`${singleLine(label)}:`, maxW)) {
+            postLines.push(`  ${YELLOW}${labelLine}${RESET}`);
         }
+        const bufLines = renderInputBuffer(state.inputMode.buffer, state.inputMode.cursor, maxW - 1);
+        for (const line of bufLines)
+            postLines.push(`  ${line}`);
         if (attachedLine !== undefined) {
             postLines.push('');
             postLines.push(attachedLine);
         }
         postLines.push('');
-        postLines.push(`  ${DIM}enter${RESET} submit  ${DIM}esc${RESET} cancel`);
+        postLines.push(`  ${DIM}enter${RESET} submit  ${DIM}^J/⌥⏎${RESET} newline  ${DIM}^O${RESET} editor  ${DIM}esc${RESET} cancel`);
     }
     else {
         postLines.push(...renderActions(interaction, state.selectedAction, maxW, response));
@@ -326,16 +209,35 @@ export function renderItemReview(state, cols, rows) {
     // just above the footer; cleared on the next keypress.
     if (state.hint !== undefined && state.hint.length > 0) {
         postLines.push('');
-        postLines.push(`  ${YELLOW}${sanitize(state.hint)}${RESET}`);
+        for (const hintLine of wrap(sanitize(state.hint), maxW)) {
+            postLines.push(`  ${YELLOW}${hintLine}${RESET}`);
+        }
     }
-    // Window the body
+    // Derive the scroll window bounds. This builder never writes back into state
+    // — the host clamps state.scrollOffset via clampItemReviewScroll before render.
     const reservedRows = preLines.length + postLines.length + 1; // +1 for footer
     const bodyHeight = Math.max(1, rows - reservedRows);
-    const overflows = bodyLines.length > bodyHeight;
-    let scroll = state.scrollOffset || 0;
     const maxScroll = Math.max(0, bodyLines.length - bodyHeight);
-    scroll = Math.max(0, Math.min(scroll, maxScroll));
-    state.scrollOffset = scroll;
+    return {
+        interaction, preLines, bodyLines, postLines,
+        maxW, bodyHeight, maxScroll, overflows: bodyLines.length > bodyHeight,
+    };
+}
+/**
+ * Clamp state.scrollOffset to the current body's scroll bounds. The host runs
+ * this as a pre-render step (from the input path) so `renderItemReview` stays a
+ * pure function of state — the clamp keeps u/d scrolling responsive without the
+ * renderer mutating state mid-frame.
+ */
+export function clampItemReviewScroll(state, cols, rows) {
+    const { maxScroll } = buildItemReviewLayout(state, cols, rows);
+    state.scrollOffset = Math.max(0, Math.min(state.scrollOffset || 0, maxScroll));
+}
+export function renderItemReview(state, cols, rows) {
+    const { interaction, preLines, bodyLines, postLines, maxW, bodyHeight, maxScroll, overflows } = buildItemReviewLayout(state, cols, rows);
+    // Read-only clamp: renderer never mutates state (clampItemReviewScroll, run
+    // pre-render, keeps state.scrollOffset itself in bounds).
+    const scroll = Math.max(0, Math.min(state.scrollOffset || 0, maxScroll));
     let visibleBody;
     if (overflows) {
         visibleBody = bodyLines.slice(scroll, scroll + bodyHeight);
@@ -428,15 +330,25 @@ function renderActions(interaction, selectedAction, maxW, existing) {
             label = 'Add overall comment  (c on an option for per-option)';
         else
             label = 'Add comment';
-        lines.push(`  ${cursor} ${DIM}[c]${RESET} ${label}`);
+        const ftLines = wrap(sanitize(label), contentMax);
+        for (let j = 0; j < ftLines.length; j++) {
+            const prefix = j === 0 ? `  ${cursor} ${DIM}[c]${RESET} ` : ' '.repeat(8);
+            lines.push(`${prefix}${ftLines[j]}`);
+        }
     }
     else if (interaction.allowFreetext && opts.length === 0) {
         const ftLabel = interaction.freetextLabel !== undefined ? interaction.freetextLabel : 'Enter response';
-        lines.push(`  ${DIM}[r]${RESET} ${ftLabel}`);
+        const ftLines = wrap(sanitize(ftLabel), contentMax);
+        for (let j = 0; j < ftLines.length; j++) {
+            const prefix = j === 0 ? `  ${DIM}[r]${RESET} ` : ' '.repeat(6);
+            lines.push(`${prefix}${ftLines[j]}`);
+        }
     }
     if (existing) {
         lines.push('');
-        lines.push(`  ${GREEN}Current: ${responseSummary(existing, interaction)}${RESET}`);
+        for (const curLine of wrap(`Current: ${responseSummary(existing, interaction)}`, maxW)) {
+            lines.push(`  ${GREEN}${curLine}${RESET}`);
+        }
     }
     return lines;
 }

package/dist/tui/terminal.d.ts

@@ -1,7 +1,18 @@
 export interface Key {
     upArrow: boolean;
     downArrow: boolean;
+    leftArrow: boolean;
+    rightArrow: boolean;
+    /** Word-wise cursor motion (ctrl/alt + arrow, or readline alt-b / alt-f). */
+    wordLeft: boolean;
+    wordRight: boolean;
+    home: boolean;
+    end: boolean;
+    /** Forward delete (the Del key / \x1b[3~). */
+    del: boolean;
     return: boolean;
+    /** Newline-insert chord (ctrl+j / alt+enter) — distinct from return=submit. */
+    newline: boolean;
     escape: boolean;
     ctrl: boolean;
     meta: boolean;

package/dist/tui/terminal.js

@@ -2,7 +2,15 @@ function emptyKey() {
     return {
         upArrow: false,
         downArrow: false,
+        leftArrow: false,
+        rightArrow: false,
+        wordLeft: false,
+        wordRight: false,
+        home: false,
+        end: false,
+        del: false,
         return: false,
+        newline: false,
         escape: false,
         ctrl: false,
         meta: false,
@@ -21,10 +29,54 @@ export function parseKeypress(data) {
         key.downArrow = true;
         return { input: '', key };
     }
-    if (str === '\r' || str === '\n') {
+    if (str === '\x1b[C') {
+        key.rightArrow = true;
+        return { input: '', key };
+    }
+    if (str === '\x1b[D') {
+        key.leftArrow = true;
+        return { input: '', key };
+    }
+    // Word-wise motion: ctrl/alt + left/right (xterm modifier encodings) and the
+    // readline alt-b / alt-f bindings. Must precede the bare-ESC checks below.
+    if (str === '\x1b[1;5C' || str === '\x1b[1;3C' || str === '\x1bf') {
+        key.wordRight = true;
+        return { input: '', key };
+    }
+    if (str === '\x1b[1;5D' || str === '\x1b[1;3D' || str === '\x1bb') {
+        key.wordLeft = true;
+        return { input: '', key };
+    }
+    if (str === '\x1b[H' || str === '\x1b[1~') {
+        key.home = true;
+        return { input: '', key };
+    }
+    if (str === '\x1b[F' || str === '\x1b[4~') {
+        key.end = true;
+        return { input: '', key };
+    }
+    if (str === '\x1b[3~') {
+        key.del = true;
+        return { input: '', key };
+    }
+    // Alt+Enter inserts a newline in freetext (distinct from Enter=submit). Must
+    // precede the bare-ESC and meta-backspace checks so the two-byte sequence
+    // isn't swallowed as a lone escape.
+    if (str === '\x1b\r' || str === '\x1b\n') {
+        key.newline = true;
+        return { input: '', key };
+    }
+    // Enter (submit) is CR; ctrl+j (LF) inserts a newline. Splitting them lets
+    // freetext use ctrl+j for a hard newline while Enter still submits. In a raw
+    // TTY the Enter key sends CR, so this split is safe.
+    if (str === '\r') {
         key.return = true;
         return { input: '', key };
     }
+    if (str === '\n') {
+        key.newline = true;
+        return { input: '', key };
+    }
     // Alt+Backspace: terminals send ESC followed by DEL/BS. Must precede the
     // bare-ESC check so the two-byte sequence isn't swallowed as plain escape.
     // iTerm2 (and many readline configs) instead map Option/Alt+Backspace to a

package/dist/types.d.ts

@@ -102,10 +102,12 @@ export type Phase = 'overview' | 'item-review' | 'final';
 export type InputMode = null | {
     kind: 'comment';
     buffer: string;
+    cursor: number;
     selectedOptionId?: string;
 } | {
     kind: 'freetext';
     buffer: string;
+    cursor: number;
 };
 export interface TuiState {
     phase: Phase;
@@ -181,6 +183,11 @@ export interface MountedPanelOpts {
     onProgress?: (responses: InteractionResponse[]) => void;
     onComplete?: (responses: InteractionResponse[]) => void;
     onExit?: () => void;
+    /** Fired when panel state changes outside a keypress — currently when an
+     *  async visual finishes loading. Hosts wire this to a repaint so
+     *  "loading context..." is replaced the moment context arrives, rather than
+     *  sticking until the next keystroke. Optional / backward-compatible. */
+    onDirty?: () => void;
 }
 export interface MountedPanel {
     handleKey(input: string, key: Key): void;
@@ -197,4 +204,15 @@ export interface MountedPanel {
      * whether Esc should step back inside the deck (false) or tear it down (true).
      */
     atDeckTop(): boolean;
+    /**
+     * Live comment/freetext buffer, or undefined when not in input mode. Lets a
+     * host implement the $EDITOR escape hatch (ctrl+o) without reaching into
+     * panel-internal state: read the buffer here before spawning the editor.
+     */
+    getInputBuffer(): string | undefined;
+    /**
+     * Replace the input-mode buffer (e.g. after an $EDITOR round-trip) and move
+     * the cursor to the end. No-op when not in input mode.
+     */
+    setInputBuffer(text: string): void;
 }

package/dist/visuals/generate.js

@@ -1,47 +1,21 @@
 import { query } from '@r-cli/sdk';
 import { renderMarkdown } from '../render/termrender.js';
-const VISUAL_SYSTEM_PROMPT = `You're briefing a CTO-level engineer in the 30 seconds before they decide. They've been off this problem for days; they need a fast re-ground in what *already exists* — the files, data flow, or constraint they're deciding inside of — not a lecture on tradeoffs.
+const VISUAL_SYSTEM_PROMPT = `You are re-grounding a decision-maker in the moment before they answer the question below. They were deep in this problem but got pulled away; in the next 20 seconds they need to remember *what is actually in play* — the current state, the files, the constraint this decision lives inside — so the question stops feeling cold and they can answer with confidence.
 
-# Length
+Write from the conversation history you're given. Lead with what *is*: the real files, functions, data, and constraints that ground this decision, named concretely (as \`path/to/file.ts:123\` so they can jump straight there). Reconstruct just enough of how they arrived here to make the question legible — no more.
 
-Target 15–25 lines. Hard cap 30. A tight paragraph with two file refs is often perfect — don't pad.
+Keep it tight: usually a short paragraph or a few bullets, 30 lines hard cap. Say less when less is true. Choose whatever shape carries the meaning fastest — prose by default, a list when enumerating, a table only to compare several things across the same dimensions, a small diagram when the structure itself is the point. You're trusted to pick; don't force a format.
 
-# What to write
+The one rule that matters: **only reference files, identifiers, and facts that actually appear in the conversation.** Never invent a plausible-looking path or name. If the conversation is thin, write a short honest briefing about what little is grounded — that beats confident fabrication every time.
 
-Lead with *what is*, not *what could be*. Name the actual files, functions, tables, or data structures in play. Reference them as \`path/to/file.ts:123\` so they can jump to it. Skip preamble. Skip "here are the tradeoffs." Skip explaining the alternative — they're deciding, they know the alternative exists.
+And stay in your lane: don't restate the question, don't recommend an option or tell them how to decide, don't lay out tradeoffs or sketch alternatives. They own the decision; you only reconstruct the ground it stands on.
 
-If one sentence captures the current state, write one sentence. If they need to see a flow, draw it. If they need to compare 3+ options across same dimensions, use a table. Don't reach for a directive unless it genuinely clarifies — plain prose + bullet lists is the default.
-
-# Directives (termrender-flavored markdown)
-
-  :::panel{title="T" color="c"}                 Bordered box (colors: red|green|yellow|blue|magenta|cyan|white|gray)
-  :::tree{color="c"}                            Indented hierarchy (2-space indent = nesting)
-  :::callout{type="info|warning|error|success"} Status callout with icon
-  ::::columns / :::col{width="50%"}             Side-by-side layout (use 4 colons on the outer columns)
-
-Each opens with ::: and closes with :::. GFM tables (\`| col | col |\` with a \`| --- |\` separator) render directly — no directive needed. Standard markdown also works: **bold**, *italic*, \`code\`, bullets.
-
-# Critical: ASCII art must live inside a :::panel
-
-Plain text outside directives gets reflowed — box-drawing will be destroyed. If you draw a flow diagram or ASCII box, wrap it in \`:::panel\` to preserve it verbatim.
-
-# Grounding — the single most important rule
-
-**Only name files, functions, variables, or patterns that actually appear in the conversation history provided.** Do not invent plausible-sounding file paths, class names, or dependencies. If the conversation doesn't ground a fact, don't assert it. When in doubt, speak at a higher level of abstraction ("the state file," "the render loop") rather than making up a specific identifier.
-
-If the conversation doesn't contain enough context to write a grounded briefing, write a very short briefing that honestly reflects what little is known — a one-paragraph summary is better than a confident fabrication.
-
-# Hard rules
-
-- When nesting directives, the outer fence needs strictly more colons than the inner — e.g. \`::::columns\` wrapping \`:::col\`. Don't nest a panel inside a panel.
-- Never wrap output in backtick fences
-- Never repeat the question/statement text
-- Never write "tradeoffs to consider" or "here are some options"
-- Never describe an alternative architecture — just describe the current one
-- Never recommend an option or tell the user how to decide. They are the decider. You describe.
-- Never ask the user a question back. You are producing a briefing, not a conversation.
-- Do NOT use these section headings: **Recommendation:**, **Decide by:**, **Trade-off:**, **Why it matters:**, **What you're locking in:**. These invite editorializing. Use neutral labels like **Current state:**, **Constraint:**, or none at all.
-- 30 lines maximum`;
+Formatting: plain markdown renders (**bold**, *italic*, \`code\`, bullets, and GFM tables). These termrender directives are available if one genuinely helps — anything you draw with box-drawing/ASCII must sit inside a :::panel or it will be reflowed and destroyed:
+  :::panel{title="T" color="cyan"}                bordered box (red|green|yellow|blue|magenta|cyan|white|gray)
+  :::tree{color="c"}                              indented hierarchy (2-space indent = nesting)
+  :::callout{type="info|warning|error|success"}   status callout
+  ::::columns / :::col{width="50%"}               side-by-side (outer fence needs strictly more colons)
+Never wrap the whole output in a code fence.`;
 async function callHaiku(prompt, systemPrompt) {
     try {
         const session = await query({
@@ -72,16 +46,26 @@ async function callHaiku(prompt, systemPrompt) {
 // mountPanel. Width is read from process.stdout.columns so callers that
 // embed humanloop in a sub-region should supply their own closure that bakes
 // in the correct width.
+// Cap on how much conversation we hand the generator. Recency is what grounds
+// the decision in front of the human, so when history is long we keep the tail
+// (most recent messages) rather than the head.
+const MAX_CONTEXT_CHARS = 24000;
 export async function defaultGenerateVisual(interaction, conversationContext) {
     const width = Math.max(40, Math.min((process.stdout.columns || 80) - 4, 76));
     const optionsSummary = interaction.options.length > 0
         ? `\nOptions: ${interaction.options.map((o) => o.label).join(' | ')}`
         : '';
     const subtitleLine = interaction.subtitle ? `\nContext: ${interaction.subtitle}` : '';
-    const questionText = `Title: "${interaction.title}"${subtitleLine}${optionsSummary}`;
-    const prompt = conversationContext
-        ? `Here is the conversation so far:\n\n${conversationContext}\n\n---\n\nGenerate a visual context block for this decision point:\n\n${questionText}`
-        : `Generate a visual context block for this decision point:\n\n${questionText}`;
+    // The body is the richest statement of what's being asked — hand it to the
+    // generator so the briefing grounds in the actual question, not just its title.
+    const bodyLine = interaction.body ? `\nDetail:\n${interaction.body}` : '';
+    const questionText = `Title: "${interaction.title}"${subtitleLine}${bodyLine}${optionsSummary}`;
+    const trimmedContext = conversationContext.length > MAX_CONTEXT_CHARS
+        ? `…(earlier conversation trimmed)…\n\n${conversationContext.slice(-MAX_CONTEXT_CHARS)}`
+        : conversationContext;
+    const prompt = trimmedContext
+        ? `Here is the conversation so far:\n\n${trimmedContext}\n\n---\n\nThe human is about to answer this decision. Re-ground them in what's in play:\n\n${questionText}`
+        : `The human is about to answer this decision. Re-ground them in what's in play:\n\n${questionText}`;
     const result = await callHaiku(prompt, VISUAL_SYSTEM_PROMPT);
     if (result) {
         const markdown = result

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crouton-kit/humanloop",
-  "version": "0.3.21",
+  "version": "0.3.23",
   "description": "Human-in-the-loop decision TUI — agents write questions, humans answer them",
   "type": "module",
   "main": "dist/index.js",