@mragentix/cli 4.2.37

package/dist/ui/hooks/useTerminalSize.js

@@ -0,0 +1,55 @@
+import { useState, useEffect, useRef, useCallback } from "react";
+import { useStdout } from "ink";
+/**
+ * Returns { columns, rows, resizeKey } and forces a React re-render whenever
+ * the terminal is resized.
+ *
+ * `columns` and `rows` update immediately on every resize event so layout
+ * stays responsive while the user drags.
+ *
+ * `resizeKey` increments once after resize events settle (300ms debounce).
+ * Use it as a React `key` on the root content wrapper to force a full
+ * remount — this is the only reliable way to make Ink re-render <Static>
+ * content that was already printed to scrollback and got corrupted by
+ * terminal text reflow.  Debounces 300ms then clears screen+scrollback
+ * and remounts.
+ */
+export function useTerminalSize() {
+    const { stdout } = useStdout();
+    const [size, setSize] = useState({
+        columns: stdout?.columns ?? 80,
+        rows: stdout?.rows ?? 24,
+    });
+    const [resizeKey, setResizeKey] = useState(0);
+    const debounceRef = useRef(null);
+    const onResize = useCallback(() => {
+        if (!stdout)
+            return;
+        // Update dimensions immediately for responsive layout
+        setSize({ columns: stdout.columns ?? 80, rows: stdout.rows ?? 24 });
+        // Debounce the resizeKey bump — only fires after the user stops dragging
+        if (debounceRef.current)
+            clearTimeout(debounceRef.current);
+        debounceRef.current = setTimeout(() => {
+            // Clear visible screen + scrollback to remove deformed ghost renders
+            // left behind by Ink re-rendering at different terminal widths during
+            // a resize drag.
+            stdout.write("\x1b[2J" + // clear visible screen
+                "\x1b[3J" + // clear scrollback buffer
+                "\x1b[H");
+            setResizeKey((k) => k + 1);
+        }, 300);
+    }, [stdout]);
+    useEffect(() => {
+        if (!stdout)
+            return;
+        stdout.on("resize", onResize);
+        return () => {
+            stdout.off("resize", onResize);
+            if (debounceRef.current)
+                clearTimeout(debounceRef.current);
+        };
+    }, [stdout, onResize]);
+    return { ...size, resizeKey };
+}
+//# sourceMappingURL=useTerminalSize.js.map

package/dist/ui/hooks/useTerminalSize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTerminalSize.js","sourceRoot":"","sources":["../../../src/ui/hooks/useTerminalSize.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,OAAO,CAAC;AACjE,OAAO,EAAE,SAAS,EAAE,MAAM,KAAK,CAAC;AAEhC;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,eAAe;IAC7B,MAAM,EAAE,MAAM,EAAE,GAAG,SAAS,EAAE,CAAC;IAC/B,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,GAAG,QAAQ,CAAC;QAC/B,OAAO,EAAE,MAAM,EAAE,OAAO,IAAI,EAAE;QAC9B,IAAI,EAAE,MAAM,EAAE,IAAI,IAAI,EAAE;KACzB,CAAC,CAAC;IACH,MAAM,CAAC,SAAS,EAAE,YAAY,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;IAC9C,MAAM,WAAW,GAAG,MAAM,CAAuC,IAAI,CAAC,CAAC;IAEvE,MAAM,QAAQ,GAAG,WAAW,CAAC,GAAG,EAAE;QAChC,IAAI,CAAC,MAAM;YAAE,OAAO;QAEpB,sDAAsD;QACtD,OAAO,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,OAAO,IAAI,EAAE,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,IAAI,EAAE,EAAE,CAAC,CAAC;QAEpE,yEAAyE;QACzE,IAAI,WAAW,CAAC,OAAO;YAAE,YAAY,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;QAC3D,WAAW,CAAC,OAAO,GAAG,UAAU,CAAC,GAAG,EAAE;YACpC,qEAAqE;YACrE,sEAAsE;YACtE,iBAAiB;YACjB,MAAM,CAAC,KAAK,CACV,SAAS,GAAG,uBAAuB;gBACjC,SAAS,GAAG,0BAA0B;gBACtC,QAAQ,CACX,CAAC;YACF,YAAY,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QAC7B,CAAC,EAAE,GAAG,CAAC,CAAC;IACV,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC;IAEb,SAAS,CAAC,GAAG,EAAE;QACb,IAAI,CAAC,MAAM;YAAE,OAAO;QACpB,MAAM,CAAC,EAAE,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;QAC9B,OAAO,GAAG,EAAE;YACV,MAAM,CAAC,GAAG,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;YAC/B,IAAI,WAAW,CAAC,OAAO;gBAAE,YAAY,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;QAC7D,CAAC,CAAC;IACJ,CAAC,EAAE,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC;IAEvB,OAAO,EAAE,GAAG,IAAI,EAAE,SAAS,EAAE,CAAC;AAChC,CAAC"}

package/dist/ui/hooks/useTerminalTitle.d.ts

@@ -0,0 +1,3 @@
+import type { ActivityPhase } from "./useAgentLoop.js";
+export declare function useTerminalTitle(phase: ActivityPhase, isRunning: boolean): void;
+//# sourceMappingURL=useTerminalTitle.d.ts.map

package/dist/ui/hooks/useTerminalTitle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTerminalTitle.d.ts","sourceRoot":"","sources":["../../../src/ui/hooks/useTerminalTitle.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAqBvD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,OAAO,GAAG,IAAI,CAqB/E"}

package/dist/ui/hooks/useTerminalTitle.js

@@ -0,0 +1,41 @@
+import { useEffect } from "react";
+import { useStdout } from "ink";
+import { SPINNER_FRAMES, SPINNER_INTERVAL } from "../spinner-frames.js";
+import { useAnimationTick, deriveFrame } from "../components/AnimationContext.js";
+function getTitleText(phase, isRunning) {
+    if (!isRunning)
+        return "MR Agentix";
+    switch (phase) {
+        case "thinking":
+            return "Thinking...";
+        case "generating":
+            return "Generating...";
+        case "tools":
+            return "Running tools...";
+        case "waiting":
+            return "Thinking...";
+        default:
+            return "MR Agentix";
+    }
+}
+export function useTerminalTitle(phase, isRunning) {
+    const { stdout } = useStdout();
+    // Derive spinner frame from global animation tick — no independent timer
+    const tick = useAnimationTick();
+    const spinnerFrame = isRunning ? deriveFrame(tick, SPINNER_INTERVAL, SPINNER_FRAMES.length) : 0;
+    // Write terminal title
+    useEffect(() => {
+        if (!stdout)
+            return;
+        const text = getTitleText(phase, isRunning);
+        const title = isRunning ? `${SPINNER_FRAMES[spinnerFrame]} ${text}` : text;
+        stdout.write(`\x1b]0;${title}\x1b\\`);
+    }, [stdout, phase, isRunning, spinnerFrame]);
+    // Reset title on unmount
+    useEffect(() => {
+        return () => {
+            stdout?.write(`\x1b]0;MR Agentix\x1b\\`);
+        };
+    }, [stdout]);
+}
+//# sourceMappingURL=useTerminalTitle.js.map

package/dist/ui/hooks/useTerminalTitle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTerminalTitle.js","sourceRoot":"","sources":["../../../src/ui/hooks/useTerminalTitle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAClC,OAAO,EAAE,SAAS,EAAE,MAAM,KAAK,CAAC;AAGhC,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACxE,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAC;AAElF,SAAS,YAAY,CAAC,KAAoB,EAAE,SAAkB;IAC5D,IAAI,CAAC,SAAS;QAAE,OAAO,YAAY,CAAC;IACpC,QAAQ,KAAK,EAAE,CAAC;QACd,KAAK,UAAU;YACb,OAAO,aAAa,CAAC;QACvB,KAAK,YAAY;YACf,OAAO,eAAe,CAAC;QACzB,KAAK,OAAO;YACV,OAAO,kBAAkB,CAAC;QAC5B,KAAK,SAAS;YACZ,OAAO,aAAa,CAAC;QACvB;YACE,OAAO,YAAY,CAAC;IACxB,CAAC;AACH,CAAC;AAED,MAAM,UAAU,gBAAgB,CAAC,KAAoB,EAAE,SAAkB;IACvE,MAAM,EAAE,MAAM,EAAE,GAAG,SAAS,EAAE,CAAC;IAE/B,yEAAyE;IACzE,MAAM,IAAI,GAAG,gBAAgB,EAAE,CAAC;IAChC,MAAM,YAAY,GAAG,SAAS,CAAC,CAAC,CAAC,WAAW,CAAC,IAAI,EAAE,gBAAgB,EAAE,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAEhG,uBAAuB;IACvB,SAAS,CAAC,GAAG,EAAE;QACb,IAAI,CAAC,MAAM;YAAE,OAAO;QACpB,MAAM,IAAI,GAAG,YAAY,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;QAC5C,MAAM,KAAK,GAAG,SAAS,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC,YAAY,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;QAC3E,MAAM,CAAC,KAAK,CAAC,UAAU,KAAK,QAAQ,CAAC,CAAC;IACxC,CAAC,EAAE,CAAC,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,YAAY,CAAC,CAAC,CAAC;IAE7C,yBAAyB;IACzB,SAAS,CAAC,GAAG,EAAE;QACb,OAAO,GAAG,EAAE;YACV,MAAM,EAAE,KAAK,CAAC,yBAAyB,CAAC,CAAC;QAC3C,CAAC,CAAC;IACJ,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC;AACf,CAAC"}

package/dist/ui/live-item-flush.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Pure functions for flushing completed live items to Static history.
+ *
+ * During an agent run, items (text blocks, tool calls, etc.) accumulate in
+ * the live area. Ink re-renders ALL live items on every state change, so if
+ * they grow unbounded the live area becomes very tall, making Ink's cursor
+ * math expensive and causing visible jank.
+ *
+ * These functions determine which items can be safely moved to Static history
+ * (where Ink writes them once and never re-renders them).
+ */
+/** Minimal item shape needed for flush logic. */
+export interface FlushableItem {
+    kind: string;
+    id: string;
+}
+/**
+ * Max history items kept in React state. Ink's <Static> renders items once
+ * to stdout, so pruned items remain visible in terminal scrollback — we just
+ * release the JS object references to avoid unbounded memory growth.
+ */
+export declare const MAX_HISTORY_ITEMS = 200;
+/**
+ * Prune history to keep at most MAX_HISTORY_ITEMS. Oldest items are dropped
+ * first; they remain visible in terminal scrollback.
+ */
+export declare function pruneHistory<T>(items: T[]): T[];
+/**
+ * Trim large payload data from items that have been flushed to Static history.
+ * Ink already rendered them to the terminal — we only keep a truncated version
+ * to prevent multi-GB memory retention from tool results, server tool data, and
+ * sub-agent results.
+ *
+ * Works with any item shape via duck-typing: truncates `result` strings,
+ * clears `input`/`data` fields, and trims sub-agent result strings.
+ */
+export declare function trimFlushedItems<T extends FlushableItem>(items: T[]): T[];
+/**
+ * Called when `onTurnText` fires (end of each LLM turn that produced text).
+ * All previous items are guaranteed complete — tool calls from this turn
+ * finished before `turn_end` fired, and `onTurnText` fires inside `turn_end`.
+ *
+ * Returns the items to flush to history. The caller should then set liveItems
+ * to contain only the new text item.
+ */
+export declare function flushOnTurnText<T extends FlushableItem>(liveItems: T[]): T[];
+/**
+ * Called when `onTurnEnd` fires with a tool_use stop reason (LLM responded
+ * with only tool calls, no text). Flushes all items IF none are still pending
+ * (no `tool_start` without a corresponding `tool_done`).
+ *
+ * Returns { flushed, remaining } — flushed items go to history, remaining
+ * items stay in liveItems.
+ */
+export declare function flushOnTurnEnd<T extends FlushableItem>(liveItems: T[], stopReason: string): {
+    flushed: T[];
+    remaining: T[];
+};
+//# sourceMappingURL=live-item-flush.d.ts.map

package/dist/ui/live-item-flush.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"live-item-flush.d.ts","sourceRoot":"","sources":["../../src/ui/live-item-flush.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,iDAAiD;AACjD,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACZ;AAED;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,MAAM,CAAC;AAUrC;;;GAGG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,CAG/C;AAQD;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,aAAa,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,CA0DzE;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,aAAa,EAAE,SAAS,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,CAE5E;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,aAAa,EACpD,SAAS,EAAE,CAAC,EAAE,EACd,UAAU,EAAE,MAAM,GACjB;IAAE,OAAO,EAAE,CAAC,EAAE,CAAC;IAAC,SAAS,EAAE,CAAC,EAAE,CAAA;CAAE,CAoBlC"}

package/dist/ui/live-item-flush.js

@@ -0,0 +1,135 @@
+/**
+ * Pure functions for flushing completed live items to Static history.
+ *
+ * During an agent run, items (text blocks, tool calls, etc.) accumulate in
+ * the live area. Ink re-renders ALL live items on every state change, so if
+ * they grow unbounded the live area becomes very tall, making Ink's cursor
+ * math expensive and causing visible jank.
+ *
+ * These functions determine which items can be safely moved to Static history
+ * (where Ink writes them once and never re-renders them).
+ */
+/**
+ * Max history items kept in React state. Ink's <Static> renders items once
+ * to stdout, so pruned items remain visible in terminal scrollback — we just
+ * release the JS object references to avoid unbounded memory growth.
+ */
+export const MAX_HISTORY_ITEMS = 200;
+/**
+ * Max characters to keep in a tool result string after the item has been
+ * flushed to Static history. Ink already rendered the full result, so we
+ * only need enough for potential re-renders (which shouldn't happen for
+ * Static items, but keep a small buffer for safety).
+ */
+const MAX_RESULT_CHARS_IN_HISTORY = 2_000;
+/**
+ * Prune history to keep at most MAX_HISTORY_ITEMS. Oldest items are dropped
+ * first; they remain visible in terminal scrollback.
+ */
+export function pruneHistory(items) {
+    if (items.length <= MAX_HISTORY_ITEMS)
+        return items;
+    return items.slice(items.length - MAX_HISTORY_ITEMS);
+}
+/** Truncate a string if it exceeds the history limit. */
+function truncateResult(s) {
+    if (s.length <= MAX_RESULT_CHARS_IN_HISTORY)
+        return s;
+    return s.slice(0, MAX_RESULT_CHARS_IN_HISTORY) + "\n… (truncated)";
+}
+/**
+ * Trim large payload data from items that have been flushed to Static history.
+ * Ink already rendered them to the terminal — we only keep a truncated version
+ * to prevent multi-GB memory retention from tool results, server tool data, and
+ * sub-agent results.
+ *
+ * Works with any item shape via duck-typing: truncates `result` strings,
+ * clears `input`/`data` fields, and trims sub-agent result strings.
+ */
+export function trimFlushedItems(items) {
+    return items.map((item) => {
+        const rec = item;
+        const patches = {};
+        let changed = false;
+        // Truncate tool result strings (ToolDoneItem, SubAgentInfo, etc.)
+        if (typeof rec.result === "string" && rec.result.length > MAX_RESULT_CHARS_IN_HISTORY) {
+            patches.result = truncateResult(rec.result);
+            changed = true;
+        }
+        // Clear server tool input/data — potentially large JSON payloads
+        if (rec.input !== undefined && rec.kind === "server_tool_done") {
+            patches.input = undefined;
+            changed = true;
+        }
+        if (rec.data !== undefined && rec.kind === "server_tool_done") {
+            patches.data = undefined;
+            changed = true;
+        }
+        // Trim tool group results
+        if (rec.kind === "tool_group" && Array.isArray(rec.tools)) {
+            const tools = rec.tools;
+            let toolsChanged = false;
+            const trimmedTools = tools.map((t) => {
+                if (typeof t.result === "string" && t.result.length > MAX_RESULT_CHARS_IN_HISTORY) {
+                    toolsChanged = true;
+                    return { ...t, result: truncateResult(t.result) };
+                }
+                return t;
+            });
+            if (toolsChanged) {
+                patches.tools = trimmedTools;
+                changed = true;
+            }
+        }
+        // Trim sub-agent group results
+        if (rec.kind === "subagent_group" && Array.isArray(rec.agents)) {
+            const agents = rec.agents;
+            let agentsChanged = false;
+            const trimmedAgents = agents.map((a) => {
+                if (typeof a.result === "string" && a.result.length > MAX_RESULT_CHARS_IN_HISTORY) {
+                    agentsChanged = true;
+                    return { ...a, result: truncateResult(a.result) };
+                }
+                return a;
+            });
+            if (agentsChanged) {
+                patches.agents = trimmedAgents;
+                changed = true;
+            }
+        }
+        return changed ? { ...item, ...patches } : item;
+    });
+}
+/**
+ * Called when `onTurnText` fires (end of each LLM turn that produced text).
+ * All previous items are guaranteed complete — tool calls from this turn
+ * finished before `turn_end` fired, and `onTurnText` fires inside `turn_end`.
+ *
+ * Returns the items to flush to history. The caller should then set liveItems
+ * to contain only the new text item.
+ */
+export function flushOnTurnText(liveItems) {
+    return liveItems;
+}
+/**
+ * Called when `onTurnEnd` fires with a tool_use stop reason (LLM responded
+ * with only tool calls, no text). Flushes all items IF none are still pending
+ * (no `tool_start` without a corresponding `tool_done`).
+ *
+ * Returns { flushed, remaining } — flushed items go to history, remaining
+ * items stay in liveItems.
+ */
+export function flushOnTurnEnd(liveItems, stopReason) {
+    if (stopReason !== "tool_use") {
+        return { flushed: [], remaining: liveItems };
+    }
+    const hasPendingToolStart = liveItems.some((item) => item.kind === "tool_start" ||
+        item.kind === "server_tool_start" ||
+        (item.kind === "tool_group" &&
+            (item.tools ?? []).some((t) => t.status === "running")));
+    if (hasPendingToolStart || liveItems.length === 0) {
+        return { flushed: [], remaining: liveItems };
+    }
+    return { flushed: liveItems, remaining: [] };
+}
+//# sourceMappingURL=live-item-flush.js.map

package/dist/ui/live-item-flush.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"live-item-flush.js","sourceRoot":"","sources":["../../src/ui/live-item-flush.ts"],"names":[],"mappings":"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"}

package/dist/ui/live-item-flush.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=live-item-flush.test.d.ts.map

package/dist/ui/live-item-flush.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"live-item-flush.test.d.ts","sourceRoot":"","sources":["../../src/ui/live-item-flush.test.ts"],"names":[],"mappings":""}

package/dist/ui/live-item-flush.test.js

@@ -0,0 +1,307 @@
+import { describe, it, expect } from "vitest";
+import { pruneHistory, flushOnTurnText, flushOnTurnEnd, MAX_HISTORY_ITEMS, } from "./live-item-flush.js";
+// ── Test helpers ──────────────────────────────────────────
+let idCounter = 0;
+function id() {
+    return `test-${++idCounter}`;
+}
+function userItem() {
+    return { kind: "user", id: id() };
+}
+function assistantItem() {
+    return { kind: "assistant", id: id() };
+}
+function toolStart(toolCallId) {
+    return { kind: "tool_start", id: id(), toolCallId: toolCallId ?? id() };
+}
+function toolDone() {
+    return { kind: "tool_done", id: id() };
+}
+function subagentGroup() {
+    return { kind: "subagent_group", id: id() };
+}
+function errorItem() {
+    return { kind: "error", id: id() };
+}
+// ── pruneHistory ──────────────────────────────────────────
+describe("pruneHistory", () => {
+    it("returns items unchanged when under the limit", () => {
+        const items = [userItem(), assistantItem(), toolDone()];
+        const result = pruneHistory(items);
+        expect(result).toBe(items); // same reference, no copy
+    });
+    it("returns items unchanged at exactly the limit", () => {
+        const items = Array.from({ length: MAX_HISTORY_ITEMS }, () => userItem());
+        const result = pruneHistory(items);
+        expect(result).toBe(items);
+    });
+    it("drops oldest items when over the limit", () => {
+        const items = Array.from({ length: MAX_HISTORY_ITEMS + 50 }, (_, i) => ({
+            kind: "user",
+            id: `item-${i}`,
+        }));
+        const result = pruneHistory(items);
+        expect(result).toHaveLength(MAX_HISTORY_ITEMS);
+        // Should keep the LAST 500 items (newest)
+        expect(result[0].id).toBe("item-50");
+        expect(result[result.length - 1].id).toBe(`item-${MAX_HISTORY_ITEMS + 49}`);
+    });
+    it("handles empty array", () => {
+        const result = pruneHistory([]);
+        expect(result).toEqual([]);
+    });
+    it("handles single item", () => {
+        const items = [userItem()];
+        const result = pruneHistory(items);
+        expect(result).toBe(items);
+    });
+});
+// ── flushOnTurnText ───────────────────────────────────────
+describe("flushOnTurnText", () => {
+    it("returns all items for flushing when liveItems is non-empty", () => {
+        const items = [assistantItem(), toolDone(), toolDone()];
+        const flushed = flushOnTurnText(items);
+        expect(flushed).toBe(items);
+        expect(flushed).toHaveLength(3);
+    });
+    it("returns empty array when liveItems is empty", () => {
+        const flushed = flushOnTurnText([]);
+        expect(flushed).toEqual([]);
+    });
+    it("flushes tool_start items (they are from a completed turn)", () => {
+        // When onTurnText fires, even stale tool_start items from the same turn
+        // are complete (tool_end already replaced them in the normal flow, but
+        // if somehow a tool_start remains, the turn is still over).
+        const items = [assistantItem(), toolStart(), toolDone()];
+        const flushed = flushOnTurnText(items);
+        expect(flushed).toHaveLength(3);
+    });
+    it("flushes mixed item types from multi-turn accumulation", () => {
+        // Simulates items accumulated across multiple turns before flush was added
+        const items = [
+            userItem(),
+            assistantItem(),
+            toolDone(),
+            toolDone(),
+            assistantItem(),
+            toolDone(),
+            toolDone(),
+            toolDone(),
+            assistantItem(),
+        ];
+        const flushed = flushOnTurnText(items);
+        expect(flushed).toHaveLength(9);
+    });
+    it("flushes subagent group items", () => {
+        const items = [assistantItem(), subagentGroup(), toolDone()];
+        const flushed = flushOnTurnText(items);
+        expect(flushed).toHaveLength(3);
+    });
+    it("flushes error items", () => {
+        const items = [errorItem(), assistantItem()];
+        const flushed = flushOnTurnText(items);
+        expect(flushed).toHaveLength(2);
+    });
+});
+// ── flushOnTurnEnd ────────────────────────────────────────
+describe("flushOnTurnEnd", () => {
+    describe("with tool_use stop reason", () => {
+        it("flushes all items when no pending tool_start exists", () => {
+            const items = [assistantItem(), toolDone(), toolDone()];
+            const { flushed, remaining } = flushOnTurnEnd(items, "tool_use");
+            expect(flushed).toBe(items);
+            expect(flushed).toHaveLength(3);
+            expect(remaining).toEqual([]);
+        });
+        it("does NOT flush when a tool_start is still pending", () => {
+            const items = [assistantItem(), toolStart(), toolDone()];
+            const { flushed, remaining } = flushOnTurnEnd(items, "tool_use");
+            expect(flushed).toEqual([]);
+            expect(remaining).toBe(items);
+            expect(remaining).toHaveLength(3);
+        });
+        it("does NOT flush when liveItems is empty", () => {
+            const { flushed, remaining } = flushOnTurnEnd([], "tool_use");
+            expect(flushed).toEqual([]);
+            expect(remaining).toEqual([]);
+        });
+        it("does NOT flush when only tool_start items exist (all pending)", () => {
+            const items = [toolStart(), toolStart()];
+            const { flushed, remaining } = flushOnTurnEnd(items, "tool_use");
+            expect(flushed).toEqual([]);
+            expect(remaining).toBe(items);
+        });
+        it("flushes when items include subagent groups with no pending tool_start", () => {
+            const items = [subagentGroup(), toolDone()];
+            const { flushed, remaining } = flushOnTurnEnd(items, "tool_use");
+            expect(flushed).toHaveLength(2);
+            expect(remaining).toEqual([]);
+        });
+    });
+    describe("with non-tool_use stop reasons", () => {
+        it("does NOT flush for end_turn stop reason", () => {
+            const items = [assistantItem(), toolDone()];
+            const { flushed, remaining } = flushOnTurnEnd(items, "end_turn");
+            expect(flushed).toEqual([]);
+            expect(remaining).toBe(items);
+        });
+        it("does NOT flush for stop_sequence stop reason", () => {
+            const items = [assistantItem()];
+            const { flushed, remaining } = flushOnTurnEnd(items, "stop_sequence");
+            expect(flushed).toEqual([]);
+            expect(remaining).toBe(items);
+        });
+        it("does NOT flush for max_tokens stop reason", () => {
+            const items = [assistantItem(), toolDone(), toolDone()];
+            const { flushed, remaining } = flushOnTurnEnd(items, "max_tokens");
+            expect(flushed).toEqual([]);
+            expect(remaining).toBe(items);
+        });
+    });
+});
+// ── Integration: simulated agent run scenarios ────────────
+describe("flush integration scenarios", () => {
+    /**
+     * Simulates the state management that App.tsx does with setLiveItems
+     * and setHistory, using the extracted pure functions.
+     */
+    function simulateRun(turns) {
+        let liveItems = [];
+        let history = [];
+        for (const turn of turns) {
+            // Simulate tool calls happening before turn_end
+            for (let i = 0; i < (turn.tools ?? 0); i++) {
+                liveItems = [...liveItems, toolStart()];
+                // Tool completes (replaces tool_start with tool_done in real code)
+                liveItems = liveItems.map((item) => item.kind === "tool_start" && liveItems.indexOf(item) === liveItems.length - 1
+                    ? toolDone()
+                    : item);
+            }
+            // onTurnEnd fires first
+            const turnEndResult = flushOnTurnEnd(liveItems, turn.stopReason);
+            if (turnEndResult.flushed.length > 0) {
+                history = pruneHistory([...history, ...turnEndResult.flushed]);
+            }
+            liveItems = turnEndResult.remaining;
+            // onTurnText fires second (only if text exists)
+            if (turn.text) {
+                const flushed = flushOnTurnText(liveItems);
+                if (flushed.length > 0) {
+                    history = pruneHistory([...history, ...flushed]);
+                }
+                liveItems = [assistantItem()]; // new text item
+            }
+        }
+        return { liveItems, history };
+    }
+    it("scenario: simple text-only conversation stays bounded", () => {
+        const { liveItems, history } = simulateRun([
+            { text: "Hello!", stopReason: "end_turn" },
+            { text: "How can I help?", stopReason: "end_turn" },
+            { text: "Sure thing.", stopReason: "end_turn" },
+        ]);
+        // Only the last text item should be live
+        expect(liveItems).toHaveLength(1);
+        expect(liveItems[0].kind).toBe("assistant");
+        // Previous text items moved to history
+        expect(history).toHaveLength(2);
+    });
+    it("scenario: text + tools cycle stays bounded", () => {
+        const { liveItems, history } = simulateRun([
+            { text: "Let me check.", tools: 3, stopReason: "end_turn" },
+            { text: "Found it.", tools: 2, stopReason: "end_turn" },
+            { text: "Done.", stopReason: "end_turn" },
+        ]);
+        expect(liveItems).toHaveLength(1);
+        // 3 tool_done + 1 assistant + 2 tool_done + 1 assistant = 7
+        expect(history).toHaveLength(7);
+    });
+    it("scenario: tool-only turns flush correctly", () => {
+        const { liveItems, history } = simulateRun([
+            { tools: 3, stopReason: "tool_use" }, // tool-only, flushed by onTurnEnd
+            { tools: 2, stopReason: "tool_use" }, // tool-only, flushed by onTurnEnd
+            { text: "All done.", stopReason: "end_turn" },
+        ]);
+        expect(liveItems).toHaveLength(1);
+        expect(liveItems[0].kind).toBe("assistant");
+        expect(history).toHaveLength(5); // 3 + 2 tool_done items
+    });
+    it("scenario: many turns — liveItems never exceeds current turn size", () => {
+        const turns = Array.from({ length: 50 }, (_, i) => ({
+            text: `Turn ${i}`,
+            tools: 5,
+            stopReason: "end_turn",
+        }));
+        const { liveItems } = simulateRun(turns);
+        // Only the last text item should remain live
+        expect(liveItems).toHaveLength(1);
+    });
+    it("scenario: alternating text and tool-only turns", () => {
+        const { liveItems, history } = simulateRun([
+            { text: "Searching...", tools: 2, stopReason: "end_turn" },
+            { tools: 3, stopReason: "tool_use" }, // tool-only
+            { text: "Found results.", tools: 1, stopReason: "end_turn" },
+            { tools: 4, stopReason: "tool_use" }, // tool-only
+            { text: "Complete.", stopReason: "end_turn" },
+        ]);
+        expect(liveItems).toHaveLength(1);
+        // History: (2 tools + 1 text) + (3 tools) + (1 tool + 1 text) + (4 tools) = 12
+        expect(history).toHaveLength(12);
+    });
+    it("scenario: stress test — 100 turns with 10 tools each", () => {
+        const turns = Array.from({ length: 100 }, () => ({
+            text: "Working...",
+            tools: 10,
+            stopReason: "end_turn",
+        }));
+        const { liveItems, history } = simulateRun(turns);
+        expect(liveItems).toHaveLength(1);
+        // Total items: 100 turns * (10 tools + 1 text) - 1 (last text is live) = 1099
+        // But pruneHistory caps at 500
+        expect(history).toHaveLength(MAX_HISTORY_ITEMS);
+    });
+    it("REGRESSION: liveItems retained after agent finishes, flushed on next submit", () => {
+        // After the agent finishes its last turn, the final AssistantItem stays
+        // in liveItems (NOT moved to Static via useEffect). This prevents Ink
+        // cursor-math glitches that caused text to get cut off during the
+        // live→Static transition. Items are flushed when the user submits the
+        // next message (simulated here by flushing before adding a new userItem).
+        let liveItems = [];
+        let history = [];
+        // Agent produces a response (turn 1)
+        const flushed1 = flushOnTurnText(liveItems);
+        if (flushed1.length > 0)
+            history = pruneHistory([...history, ...flushed1]);
+        liveItems = [assistantItem()];
+        // Agent finishes — liveItems NOT cleared (no useEffect flush)
+        // The final response stays in liveItems
+        expect(liveItems).toHaveLength(1);
+        expect(liveItems[0].kind).toBe("assistant");
+        // User submits next message — NOW flush to Static
+        if (liveItems.length > 0) {
+            history = pruneHistory([...history, ...liveItems]);
+        }
+        liveItems = [userItem()];
+        // Previous AssistantItem is now in history
+        expect(history).toHaveLength(1);
+        expect(history[0].kind).toBe("assistant");
+        // New user message is in liveItems
+        expect(liveItems).toHaveLength(1);
+        expect(liveItems[0].kind).toBe("user");
+    });
+    it("REGRESSION: without flush, liveItems would grow unbounded", () => {
+        // This test documents the old behavior — liveItems would contain
+        // ALL items from ALL turns. With 20 turns of 5 tools each, that's
+        // 20 * (5 + 1) = 120 items re-rendered on every timer tick.
+        // With the fix, liveItems is always at most 1 item (current text).
+        const turns = Array.from({ length: 20 }, () => ({
+            text: "Working...",
+            tools: 5,
+            stopReason: "end_turn",
+        }));
+        const { liveItems } = simulateRun(turns);
+        // The whole point: liveItems MUST be bounded
+        expect(liveItems.length).toBeLessThanOrEqual(1);
+    });
+});
+//# sourceMappingURL=live-item-flush.test.js.map