@bubblebrain-ai/bubble 0.0.19 → 0.0.21

package/dist/tui-ink/display-history.d.ts

@@ -1,18 +1,33 @@
 import type { Message, ToolResultMetadata } from "../types.js";
+export type UserInputStatus = "queued" | "pending_steer";
 export interface DisplayMessage {
     /** Stable identity, used as the transcript list key. Generated by the UI layer. */
     key?: string;
     role: "user" | "assistant" | "error";
     content: string;
+    /** Correlates queued/steer placeholder rows with their lifecycle events. */
+    clientId?: string;
+    /** Badge for user input waiting to enter the run (QUEUED / STEER). */
+    inputStatus?: UserInputStatus;
     reasoning?: string;
     toolCalls?: DisplayToolCall[];
     parts?: DisplayMessagePart[];
-    syntheticKind?: "ui_summary" | "ui_compact_summary";
+    syntheticKind?: "ui_summary" | "ui_compact_summary" | "ui_interrupt";
     /** Markdown body shown inside a `ui_compact_summary` card. */
     compactionSummary?: string;
     hiddenCount?: number;
     taskElapsedMs?: number;
 }
+export declare function userInputStatusBadgeLabel(status?: UserInputStatus): string | undefined;
+export declare function setUserInputStatus(message: DisplayMessage, inputStatus?: UserInputStatus): DisplayMessage;
+/**
+ * Aborted assistant messages carry a model-facing interruption note appended
+ * to their content (whole content, or a "\n\n"-joined suffix after partial
+ * streamed text). That note is for the next model call, not the user — strip
+ * it so only what the assistant actually said renders, and let the caller
+ * show a dedicated interrupt indicator instead.
+ */
+export declare function stripInterruptedAssistantMarker(content: string, marker: string): string;
 export type DisplayMessagePart = DisplayTextPart | DisplayToolsPart;
 export interface DisplayTextPart {
     type: "text";

package/dist/tui-ink/display-history.js

@@ -1,3 +1,36 @@
+export function userInputStatusBadgeLabel(status) {
+    switch (status) {
+        case "queued":
+            return "QUEUED";
+        case "pending_steer":
+            return "STEER";
+        default:
+            return undefined;
+    }
+}
+export function setUserInputStatus(message, inputStatus) {
+    if (inputStatus)
+        return { ...message, inputStatus };
+    const { inputStatus: _inputStatus, ...rest } = message;
+    return rest;
+}
+/**
+ * Aborted assistant messages carry a model-facing interruption note appended
+ * to their content (whole content, or a "\n\n"-joined suffix after partial
+ * streamed text). That note is for the next model call, not the user — strip
+ * it so only what the assistant actually said renders, and let the caller
+ * show a dedicated interrupt indicator instead.
+ */
+export function stripInterruptedAssistantMarker(content, marker) {
+    if (!content || !marker)
+        return content;
+    if (content === marker)
+        return "";
+    const suffix = `\n\n${marker}`;
+    if (content.endsWith(suffix))
+        return content.slice(0, -suffix.length);
+    return content;
+}
 let __displayMessageCounter = 0;
 export function nextDisplayMessageKey(prefix = "msg") {
     __displayMessageCounter += 1;
@@ -44,8 +77,11 @@ export function toolCallsFromParts(parts) {
     return parts.flatMap((part) => part.type === "tools" ? part.toolCalls : []);
 }
 const FULL_DETAIL_WINDOW = 24;
-const MAX_OLD_CONTENT_CHARS = 1200;
-const MAX_OLD_REASONING_CHARS = 600;
+// Folding policy: message text (content, reasoning) is NEVER rewritten or
+// truncated — what the user or the assistant said renders verbatim. All
+// messages stay in the list (the alt-screen viewport scrolls them); older
+// messages only collapse bulky tool-result bodies, which the UI re-expands
+// on demand.
 export function compactDisplayMessages(messages) {
     if (messages.length === 0) {
         return messages;
@@ -54,28 +90,24 @@ export function compactDisplayMessages(messages) {
     const detailStart = Math.max(0, visible.length - FULL_DETAIL_WINDOW);
     return visible.map((message, index) => (index < detailStart ? compactDisplayMessage(message) : message));
 }
+// Messages that already went through compaction. Re-compacting them would
+// produce equal-but-new objects on every transcript update, which defeats the
+// React.memo row cache in message-list.tsx — settled rows must keep identity.
+const compactedMessages = new WeakSet();
 function compactDisplayMessage(message) {
-    if (message.syntheticKind === "ui_summary" || message.syntheticKind === "ui_compact_summary") {
+    if (message.syntheticKind) {
         return message;
     }
-    return {
+    if (compactedMessages.has(message)) {
+        return message;
+    }
+    const compacted = {
         ...message,
-        content: truncateText(message.content, MAX_OLD_CONTENT_CHARS),
-        reasoning: message.reasoning
-            ? truncateText(message.reasoning, MAX_OLD_REASONING_CHARS)
-            : message.reasoning,
         toolCalls: message.toolCalls?.map(compactToolCall),
         parts: message.parts?.map(compactDisplayPart),
     };
-}
-function truncateText(value, maxChars) {
-    if (value.length <= maxChars) {
-        return value;
-    }
-    const head = Math.max(1, Math.floor(maxChars * 0.7));
-    const tail = Math.max(1, maxChars - head - 32);
-    const omitted = value.length - head - tail;
-    return `${value.slice(0, head)}\n...[${omitted} chars omitted for UI]...\n${value.slice(-tail)}`;
+    compactedMessages.add(compacted);
+    return compacted;
 }
 function cloneToolCall(toolCall) {
     return {
@@ -85,10 +117,7 @@ function cloneToolCall(toolCall) {
 }
 function compactDisplayPart(part) {
     if (part.type === "text") {
-        return {
-            ...part,
-            content: truncateText(part.content, MAX_OLD_CONTENT_CHARS),
-        };
+        return part;
     }
     return {
         type: "tools",

package/dist/tui-ink/footer.d.ts

@@ -1,19 +1,13 @@
 import type { PermissionMode } from "../types.js";
-export interface FooterUsageTotals {
-    prompt: number;
-    completion: number;
-}
 export interface FooterData {
-    cwd: string;
-    providerId: string;
-    model: string;
-    thinkingLevel: string;
-    showThinking: boolean;
     mode?: PermissionMode;
-    usageTotals: FooterUsageTotals;
-    verboseTrace?: boolean;
 }
+/**
+ * Bottom status line. Path / provider / model moved into the welcome banner;
+ * the footer only surfaces the permission-mode badge, so it renders nothing
+ * (zero rows) in the default mode.
+ */
 export declare function FooterBar({ data }: {
     data: FooterData;
-}): import("react/jsx-runtime").JSX.Element;
+}): import("react/jsx-runtime").JSX.Element | null;
 export declare function buildFooterData(input: FooterData): FooterData;

package/dist/tui-ink/footer.js

@@ -1,19 +1,16 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { Box, Text } from "ink";
-import { homedir } from "node:os";
 import { useTheme } from "./theme.js";
 import { PERMISSION_MODE_INFO } from "../permission/mode.js";
+/**
+ * Bottom status line. Path / provider / model moved into the welcome banner;
+ * the footer only surfaces the permission-mode badge, so it renders nothing
+ * (zero rows) in the default mode.
+ */
 export function FooterBar({ data }) {
-    const theme = useTheme();
-    const usageText = data.usageTotals.prompt || data.usageTotals.completion
-        ? `↑${formatTokens(data.usageTotals.prompt)} ↓${formatTokens(data.usageTotals.completion)}`
-        : "";
-    const thinkingText = data.showThinking
-        ? data.thinkingLevel && data.thinkingLevel !== "off"
-            ? ` • ⌃R ${data.thinkingLevel}`
-            : " • ⌃R off"
-        : "";
-    return (_jsxs(Box, { paddingX: 1, flexShrink: 0, children: [_jsx(Text, { color: theme.muted, children: formatCwd(data.cwd) }), usageText && (_jsxs(_Fragment, { children: [_jsx(Text, { color: theme.muted, children: "  " }), _jsx(Text, { color: theme.muted, dimColor: true, children: usageText })] })), _jsx(ModeBadge, { mode: data.mode }), _jsx(Box, { flexGrow: 1 }), _jsx(Text, { color: theme.muted, children: data.providerId }), _jsx(Text, { color: theme.muted, children: " \u2022 " }), _jsx(Text, { color: theme.toolName, children: data.model }), _jsx(Text, { color: theme.muted, dimColor: true, children: thinkingText })] }));
+    if (!data.mode || data.mode === "default")
+        return null;
+    return (_jsx(Box, { paddingX: 1, flexShrink: 0, children: _jsx(ModeBadge, { mode: data.mode }) }));
 }
 function ModeBadge({ mode }) {
     const theme = useTheme();
@@ -22,24 +19,8 @@ function ModeBadge({ mode }) {
     const info = PERMISSION_MODE_INFO[mode];
     const color = theme[info.color] ?? theme.muted;
     const symbol = info.symbol ? `${info.symbol} ` : "";
-    return (_jsxs(_Fragment, { children: [_jsx(Text, { color: theme.muted, children: "  " }), _jsxs(Text, { color: color, bold: true, children: [symbol, info.shortTitle, " on"] }), _jsx(Text, { color: theme.muted, children: " \u21E7\u21E5" })] }));
+    return (_jsxs(_Fragment, { children: [_jsxs(Text, { color: color, bold: true, children: [symbol, info.shortTitle, " on"] }), _jsx(Text, { color: theme.muted, children: " \u21E7\u21E5" })] }));
 }
 export function buildFooterData(input) {
     return input;
 }
-function formatTokens(count) {
-    if (count < 1000)
-        return String(count);
-    if (count < 10000)
-        return `${(count / 1000).toFixed(1)}k`;
-    if (count < 1000000)
-        return `${Math.round(count / 1000)}k`;
-    return `${(count / 1000000).toFixed(1)}M`;
-}
-function formatCwd(cwd) {
-    const home = homedir();
-    if (cwd.startsWith(home)) {
-        return `~${cwd.slice(home.length)}`;
-    }
-    return cwd;
-}

package/dist/tui-ink/image-paste.d.ts

@@ -7,6 +7,7 @@
  * TemporaryItems path and the clipboard — the path often gets cleaned up before
  * we can read it, so we fall back to the clipboard.
  */
+import type { ContentPart } from "../types.js";
 export interface ImageAttachment {
     base64: string;
     mediaType: string;
@@ -17,7 +18,47 @@ export interface ImageAttachment {
     filename?: string;
     sourcePath?: string;
 }
+export interface ImagePathToken {
+    rawPath: string;
+    start: number;
+    end: number;
+}
+export interface ImageInputResolution {
+    actualInput: string | ContentPart[];
+    displayInput: string;
+    errors: string[];
+    attachments: ImageAttachment[];
+    imagePathCount: number;
+}
+export interface LabeledImageAttachment extends ImageAttachment {
+    label: string;
+}
+export interface ComposerImageResolution {
+    text: string;
+    attachments: LabeledImageAttachment[];
+    errors: string[];
+    imagePathCount: number;
+    nextLabelIndex: number;
+}
 export declare function isImageFilePath(raw: string): boolean;
+export declare function extractImagePathTokens(input: string): ImagePathToken[];
+export declare function removeImagePathTokens(input: string, tokens: ImagePathToken[]): string;
+export declare function imageAttachmentLabel(att: ImageAttachment, index: number): string;
+/**
+ * Label for an image path before ingestion runs. Matches what
+ * imageAttachmentLabel produces for the same file, so a label inserted at
+ * paste time stays a valid key once the attachment is registered.
+ */
+export declare function imageLabelForPath(rawPath: string, index: number): string;
+export declare function imageAttachmentReference(att: ImageAttachment, index: number): string;
+export declare function imageAttachmentLabelPattern(): RegExp;
+export declare function buildImageContentParts(promptText: string, attachments: ImageAttachment[]): ContentPart[];
+export declare function formatImageDisplayInput(promptText: string, attachments: ImageAttachment[], labelStart?: number): string;
+export declare function buildImageContentPartsFromLabels(input: string, attachmentsByLabel: Map<string, ImageAttachment>): {
+    actualInput?: ContentPart[];
+    displayInput: string;
+    usedLabels: string[];
+};
 /**
  * Split a pasted blob into candidate path tokens.
  *
@@ -26,6 +67,18 @@ export declare function isImageFilePath(raw: string): boolean;
  * only on a space that is followed by the start of a new absolute path.
  */
 export declare function splitPastedPaths(pasted: string): string[];
+/**
+ * True when a pasted blob consists solely of image file paths (drag from
+ * Finder, or a terminal that converts clipboard images to temp-file paths).
+ */
+export declare function isImagePathPaste(pasted: string): boolean;
+/**
+ * Bare image filename with no directory, e.g. "Screenshot ... AM.png".
+ * Copying an image file in Finder puts only the file's NAME in the
+ * clipboard's plain-text flavor — the actual bits arrive as a file-url or
+ * image flavor that must be read from the clipboard separately.
+ */
+export declare function bareImageFilenameFromPaste(pasted: string): string | null;
 export declare function readImageFromPath(rawPath: string): Promise<ImageAttachment | null>;
 /** macOS screenshot shortcut writes to these paths and they may be auto-cleaned. */
 export declare function isScreenshotTempPath(s: string): boolean;
@@ -52,3 +105,9 @@ export declare function ingestClipboardImage(): Promise<{
     attachment?: ImageAttachment;
     error?: string;
 }>;
+export declare function resolveImageInput(input: string, options?: {
+    labelStart?: number;
+}): Promise<ImageInputResolution>;
+export declare function resolveComposerImagePaths(input: string, options?: {
+    labelStart?: number;
+}): Promise<ComposerImageResolution>;

package/dist/tui-ink/image-paste.js

@@ -14,6 +14,7 @@ import path from "node:path";
 import { promisify } from "node:util";
 const execFileAsync = promisify(execFile);
 const IMAGE_EXT = /\.(png|jpe?g|gif|webp|bmp)$/i;
+const IMAGE_EXT_SOURCE = String.raw `(?:png|jpe?g|gif|webp|bmp)`;
 // Anthropic/OpenAI image uploads cap at ~5MB base64. We target a bit below so
 // the base64 inflation (4/3) doesn't push us over.
 const MAX_BASE64_BYTES = 5 * 1024 * 1024;
@@ -30,6 +31,121 @@ export function isImageFilePath(raw) {
     // be treated as a path.
     return path.isAbsolute(s) || s.startsWith("~") || /^[A-Za-z]:\\/.test(s);
 }
+export function extractImagePathTokens(input) {
+    const pattern = new RegExp(String.raw `(^|\s)(?:"([^"]+\.${IMAGE_EXT_SOURCE})"|'([^']+\.${IMAGE_EXT_SOURCE})'|((?:~|\/|[A-Za-z]:\\)(?:\\ |[^\s"'<>])+\.${IMAGE_EXT_SOURCE}))(?=$|\s)`, "gi");
+    const tokens = [];
+    for (const match of input.matchAll(pattern)) {
+        const leading = match[1] ?? "";
+        const rawPath = match[2] ?? match[3] ?? match[4];
+        if (!rawPath || !isImageFilePath(rawPath))
+            continue;
+        const start = (match.index ?? 0) + leading.length;
+        const end = (match.index ?? 0) + match[0].length;
+        tokens.push({ rawPath, start, end });
+    }
+    return tokens;
+}
+export function removeImagePathTokens(input, tokens) {
+    if (tokens.length === 0)
+        return input.trim();
+    let out = "";
+    let cursor = 0;
+    for (const token of tokens) {
+        out += input.slice(cursor, token.start);
+        out += " ";
+        cursor = token.end;
+    }
+    out += input.slice(cursor);
+    return out
+        .replace(/[ \t]+/g, " ")
+        .replace(/ *\n */g, "\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+}
+export function imageAttachmentLabel(att, index) {
+    return `image#${index}${imageExtension(att)}`;
+}
+/**
+ * Label for an image path before ingestion runs. Matches what
+ * imageAttachmentLabel produces for the same file, so a label inserted at
+ * paste time stays a valid key once the attachment is registered.
+ */
+export function imageLabelForPath(rawPath, index) {
+    const ext = path.extname(unescapeShell(rawPath.trim())).toLowerCase() || ".png";
+    return `image#${index}${ext}`;
+}
+export function imageAttachmentReference(att, index) {
+    return `[${imageAttachmentLabel(att, index)}]`;
+}
+export function imageAttachmentLabelPattern() {
+    return /\[image#(\d+)\.[^\]\s]+\]/g;
+}
+function defaultImagePrompt(count) {
+    return count === 1
+        ? "Please analyze the attached image."
+        : "Please analyze the attached images.";
+}
+function imageExtension(att) {
+    const fromPath = path.extname(att.filename ?? att.sourcePath ?? "").toLowerCase();
+    if (fromPath)
+        return fromPath;
+    if (att.mediaType === "image/jpeg")
+        return ".jpg";
+    if (att.mediaType === "image/webp")
+        return ".webp";
+    if (att.mediaType === "image/gif")
+        return ".gif";
+    if (att.mediaType === "image/bmp")
+        return ".bmp";
+    return ".png";
+}
+export function buildImageContentParts(promptText, attachments) {
+    const text = promptText.trim() || defaultImagePrompt(attachments.length);
+    return [
+        { type: "text", text },
+        ...attachments.map((attachment) => ({
+            type: "image_url",
+            image_url: { url: attachment.dataUrl },
+        })),
+    ];
+}
+export function formatImageDisplayInput(promptText, attachments, labelStart = 1) {
+    const text = promptText.trim() || defaultImagePrompt(attachments.length);
+    const imageLines = attachments.map((attachment, index) => imageAttachmentReference(attachment, labelStart + index));
+    return `${text}\n${imageLines.join("\n")}`;
+}
+export function buildImageContentPartsFromLabels(input, attachmentsByLabel) {
+    const matches = Array.from(input.matchAll(imageAttachmentLabelPattern()));
+    const usedLabels = [];
+    const parts = [];
+    let cursor = 0;
+    for (const match of matches) {
+        const label = match[0].slice(1, -1);
+        const attachment = attachmentsByLabel.get(label);
+        if (!attachment)
+            continue;
+        const start = match.index ?? 0;
+        const before = input.slice(cursor, start).trim();
+        if (before)
+            parts.push({ type: "text", text: before });
+        parts.push({ type: "image_url", image_url: { url: attachment.dataUrl } });
+        usedLabels.push(label);
+        cursor = start + match[0].length;
+    }
+    if (usedLabels.length === 0)
+        return { displayInput: input, usedLabels: [] };
+    const rest = input.slice(cursor).trim();
+    if (rest)
+        parts.push({ type: "text", text: rest });
+    if (!parts.some((part) => part.type === "text")) {
+        parts.unshift({ type: "text", text: defaultImagePrompt(usedLabels.length) });
+    }
+    return {
+        actualInput: parts,
+        displayInput: input.trim() || usedLabels.map((label) => `[${label}]`).join("\n"),
+        usedLabels,
+    };
+}
 /**
  * Split a pasted blob into candidate path tokens.
  *
@@ -48,6 +164,30 @@ export function splitPastedPaths(pasted) {
     }
     return out;
 }
+/**
+ * True when a pasted blob consists solely of image file paths (drag from
+ * Finder, or a terminal that converts clipboard images to temp-file paths).
+ */
+export function isImagePathPaste(pasted) {
+    const pieces = splitPastedPaths(pasted);
+    return pieces.length > 0 && pieces.every((piece) => isImageFilePath(piece));
+}
+/**
+ * Bare image filename with no directory, e.g. "Screenshot ... AM.png".
+ * Copying an image file in Finder puts only the file's NAME in the
+ * clipboard's plain-text flavor — the actual bits arrive as a file-url or
+ * image flavor that must be read from the clipboard separately.
+ */
+export function bareImageFilenameFromPaste(pasted) {
+    const s = pasted.trim();
+    if (!s || s.length > 255)
+        return null;
+    if (/[\n\r/\\]/.test(s))
+        return null;
+    if (!IMAGE_EXT.test(s))
+        return null;
+    return s;
+}
 function mediaTypeFromExt(p) {
     const ext = path.extname(p).toLowerCase();
     if (ext === ".jpg" || ext === ".jpeg")
@@ -277,6 +417,14 @@ export async function ingestImagePath(p) {
     return { attachment: sized };
 }
 export async function ingestClipboardImage() {
+    // A file reference wins over bitmap flavors: for a copied FILE, coercing
+    // the clipboard to PNGf yields the file's generic ICON, not the image.
+    const filePath = await getClipboardFilePath();
+    if (filePath) {
+        if (isImageFilePath(filePath))
+            return ingestImagePath(filePath);
+        return { error: `clipboard file is not an image: ${filePath}` };
+    }
     const raw = await getImageFromClipboard();
     if (!raw)
         return { error: "clipboard has no image" };
@@ -286,3 +434,132 @@ export async function ingestClipboardImage() {
         return { error: validation.reason };
     return { attachment: sized };
 }
+async function getClipboardFilePath() {
+    if (process.platform !== "darwin")
+        return null;
+    try {
+        // Probe first — AppleScript happily coerces plain TEXT into a file URL,
+        // so only trust «class furl» when the clipboard really carries one.
+        const probe = await execFileAsync("osascript", ["-e", "clipboard info for «class furl»"], {
+            timeout: 5000,
+        });
+        if (!String(probe.stdout).includes("furl"))
+            return null;
+        const result = await execFileAsync("osascript", ["-e", "POSIX path of (the clipboard as «class furl»)"], { timeout: 5000 });
+        const p = String(result.stdout).trim();
+        return p || null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function resolveImageInput(input, options = {}) {
+    const tokens = extractImagePathTokens(input);
+    if (tokens.length === 0) {
+        return {
+            actualInput: input,
+            displayInput: input,
+            errors: [],
+            attachments: [],
+            imagePathCount: 0,
+        };
+    }
+    const attachments = [];
+    const errors = [];
+    const attachmentsByToken = new Map();
+    let nextLabelIndex = options.labelStart ?? 1;
+    for (const token of tokens) {
+        const result = await ingestImagePath(token.rawPath);
+        if (result.attachment) {
+            attachments.push(result.attachment);
+            attachmentsByToken.set(token, {
+                attachment: result.attachment,
+                label: imageAttachmentLabel(result.attachment, nextLabelIndex++),
+            });
+        }
+        else {
+            errors.push(`${token.rawPath}: ${result.error ?? "could not attach image"}`);
+        }
+    }
+    if (attachments.length === 0) {
+        return {
+            actualInput: input,
+            displayInput: input,
+            errors,
+            attachments: [],
+            imagePathCount: tokens.length,
+        };
+    }
+    const parts = [];
+    let displayInput = "";
+    let cursor = 0;
+    for (const token of tokens) {
+        const entry = attachmentsByToken.get(token);
+        if (!entry)
+            continue;
+        const before = input.slice(cursor, token.start);
+        displayInput += before;
+        const text = before.trim();
+        if (text)
+            parts.push({ type: "text", text });
+        parts.push({ type: "image_url", image_url: { url: entry.attachment.dataUrl } });
+        displayInput += `[${entry.label}]`;
+        cursor = token.end;
+    }
+    const rest = input.slice(cursor);
+    displayInput += rest;
+    const restText = rest.trim();
+    if (restText)
+        parts.push({ type: "text", text: restText });
+    if (!parts.some((part) => part.type === "text")) {
+        parts.unshift({ type: "text", text: defaultImagePrompt(attachments.length) });
+    }
+    return {
+        actualInput: parts,
+        displayInput: displayInput.trim(),
+        errors,
+        attachments,
+        imagePathCount: tokens.length,
+    };
+}
+export async function resolveComposerImagePaths(input, options = {}) {
+    const tokens = extractImagePathTokens(input);
+    let nextLabelIndex = options.labelStart ?? 1;
+    if (tokens.length === 0) {
+        return {
+            text: input,
+            attachments: [],
+            errors: [],
+            imagePathCount: 0,
+            nextLabelIndex,
+        };
+    }
+    const errors = [];
+    const attachments = [];
+    const replacements = new Map();
+    for (const token of tokens) {
+        const result = await ingestImagePath(token.rawPath);
+        if (!result.attachment) {
+            errors.push(`${token.rawPath}: ${result.error ?? "could not attach image"}`);
+            continue;
+        }
+        const label = imageAttachmentLabel(result.attachment, nextLabelIndex++);
+        attachments.push({ ...result.attachment, label });
+        replacements.set(token, `[${label}]`);
+    }
+    let text = "";
+    let cursor = 0;
+    for (const token of tokens) {
+        text += input.slice(cursor, token.start);
+        text += replacements.get(token) ?? input.slice(token.start, token.end);
+        cursor = token.end;
+    }
+    text += input.slice(cursor);
+    return {
+        text,
+        attachments,
+        errors,
+        imagePathCount: tokens.length,
+        nextLabelIndex,
+    };
+}

package/dist/tui-ink/input-box.d.ts

@@ -10,6 +10,16 @@ export interface SubmitPayload {
 }
 interface InputBoxProps {
     onSubmit: (payload: SubmitPayload) => void;
+    /**
+     * When set (agent running), Tab queues the composer content for the next
+     * turn instead of its idle-time behavior.
+     */
+    onQueue?: (payload: SubmitPayload) => void;
+    /**
+     * Receives scroll intent when Up/Down arrows are classified as synthetic
+     * wheel events (terminal alternate-scroll) rather than keyboard presses.
+     */
+    onWheelScroll?: (direction: "up" | "down", lines: number) => void;
     onPasteNotice?: (notice: string) => void;
     disabled?: boolean;
     cursorResetEpoch?: number;
@@ -31,6 +41,21 @@ export declare function resolveCursorRowCompensation(input: {
 export declare function isCtrlCInput(input: string, key: {
     ctrl?: boolean;
 }): boolean;
+/**
+ * Split a composer line around the cursor so the cell under it can render as
+ * an inverse-video software cursor. The visible cursor must not depend on the
+ * real terminal cursor: Ink only re-arms its one-shot cursor escape when the
+ * component owning useCursor re-commits, so frames produced by other
+ * components' local state (the waiting spinner, viewport scrolling) hide the
+ * hardware cursor for most of an agent run. Drawing the cell ourselves keeps
+ * the cursor visible on every frame; the real (mostly hidden) cursor is still
+ * positioned for IME anchoring.
+ */
+export declare function splitLineAtCursor(lineText: string, charOffset: number): {
+    before: string;
+    at: string;
+    after: string;
+};
 export declare function shouldSubmitExactSlashSuggestion(input: string, suggestionName?: string): boolean;
 export declare function resolveSlashEnterAction(input: string, suggestions: Array<{
     name: string;
@@ -55,4 +80,4 @@ export declare function insertNewlineAtCursor(text: string, cursor: number): {
     text: string;
     cursor: number;
 };
-export declare function InputBox({ onSubmit, onPasteNotice, disabled, cursorResetEpoch, draftText, draftEpoch, onDraftApplied, skillRegistry, terminalColumns, cwd, }: InputBoxProps): import("react/jsx-runtime").JSX.Element;
+export declare function InputBox({ onSubmit, onQueue, onWheelScroll, onPasteNotice, disabled, cursorResetEpoch, draftText, draftEpoch, onDraftApplied, skillRegistry, terminalColumns, cwd, }: InputBoxProps): import("react/jsx-runtime").JSX.Element;