@caupulican/pi-adaptative 0.80.31 → 0.80.37

package/dist/modes/interactive/interactive-mode.js

@@ -68,6 +68,12 @@ import { TrustSelectorComponent } from "./components/trust-selector.js";
 import { UserMessageComponent } from "./components/user-message.js";
 import { UserMessageSelectorComponent } from "./components/user-message-selector.js";
 import { getAvailableThemes, getAvailableThemesWithPaths, getEditorTheme, getMarkdownTheme, getThemeByName, initTheme, onThemeChange, setRegisteredThemes, setTheme, setThemeInstance, stopThemeWatcher, Theme, theme, } from "./theme/theme.js";
+const TUI_HISTORY_RELOAD_MAX_LINES = 1000;
+const TUI_HISTORY_RELOAD_WRAP_WIDTH = 100;
+const TUI_HISTORY_RELOAD_CHUNK_SIZE = 20;
+const TUI_LIVE_HISTORY_MAX_COMPONENTS = 260;
+const TUI_LIVE_HISTORY_TRIM_TO_COMPONENTS = 220;
+const STREAMING_UI_UPDATE_INTERVAL_MS = 80;
 function isExpandable(obj) {
     return typeof obj === "object" && obj !== null && "setExpanded" in obj && typeof obj.setExpanded === "function";
 }
@@ -102,7 +108,7 @@ const AUTO_LEARN_DEFAULTS = {
     maxConcurrentLearners: 1,
     applyHighConfidence: false,
     reflectionReview: true,
-    reflectionMinToolCalls: 8,
+    reflectionMinToolCalls: 5,
     reflectionCooldownMinutes: 24 * 60,
 };
 const AUTONOMY_AUTO_LEARN_PRESETS = {
@@ -117,7 +123,7 @@ const AUTONOMY_AUTO_LEARN_PRESETS = {
         maxConcurrentLearners: 1,
         applyHighConfidence: false,
         reflectionReview: true,
-        reflectionMinToolCalls: 8,
+        reflectionMinToolCalls: 5,
         reflectionCooldownMinutes: 24 * 60,
     },
     balanced: {
@@ -130,7 +136,7 @@ const AUTONOMY_AUTO_LEARN_PRESETS = {
         maxConcurrentLearners: 1,
         applyHighConfidence: false,
         reflectionReview: true,
-        reflectionMinToolCalls: 8,
+        reflectionMinToolCalls: 5,
         reflectionCooldownMinutes: 24 * 60,
     },
     full: {
@@ -143,13 +149,14 @@ const AUTONOMY_AUTO_LEARN_PRESETS = {
         maxConcurrentLearners: 1,
         applyHighConfidence: true,
         reflectionReview: true,
-        reflectionMinToolCalls: 8,
+        reflectionMinToolCalls: 5,
         reflectionCooldownMinutes: 24 * 60,
     },
 };
 const AUTONOMY_MODES = ["off", "safe", "balanced", "full"];
 const AUTO_LEARN_RESERVATION_MS = 2 * 60 * 1000;
 const AUTO_LEARN_THINKING_LEVEL = "xhigh";
+const AUTO_LEARN_COMPLEX_TASK_TOOL_CALLS = 5;
 export const AUTO_LEARN_HISTORY_RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
 function definedStringSet(values) {
     const set = new Set();
@@ -407,9 +414,16 @@ export class InteractiveMode {
     // Status line tracking (for mutating immediately-sequential status updates)
     lastStatusSpacer = undefined;
     lastStatusText = undefined;
+    // Live TUI history cap. Full session history remains in SessionManager/model state.
+    liveHistoryHiddenNotice = undefined;
+    liveHistoryHiddenComponents = 0;
+    tuiHistoryLoaded = false;
+    tuiHistoryLoadInProgress = false;
     // Streaming message tracking
     streamingComponent = undefined;
     streamingMessage = undefined;
+    streamingUiUpdateTimer = undefined;
+    lastStreamingUiUpdateAt = 0;
     // Tool execution tracking and session-scoped reusable panels
     toolPanels = new ToolPanelRegistry();
     // Tool output expansion state
@@ -687,7 +701,7 @@ export class InteractiveMode {
                 hint("app.thinking.cycle", "to cycle thinking level"),
                 rawKeyHint(`${keyText("app.model.cycleForward")}/${keyText("app.model.cycleBackward")}`, "to cycle models"),
                 hint("app.model.select", "to select model"),
-                hint("app.tools.expand", "to expand tools"),
+                hint("app.tools.expand", "to load history / expand tools"),
                 hint("app.thinking.toggle", "to expand thinking"),
                 hint("app.editor.external", "for external editor"),
                 rawKeyHint("/", "for commands"),
@@ -705,9 +719,9 @@ export class InteractiveMode {
                 rawKeyHint(`${keyText("app.clear")}/${keyText("app.exit")}`, "clear/exit"),
                 rawKeyHint("/", "commands"),
                 rawKeyHint("!", "bash"),
-                hint("app.tools.expand", "more"),
+                hint("app.tools.expand", "history/more"),
             ].join(theme.fg("muted", " · "));
-            const compactOnboarding = theme.fg("dim", `Press ${keyText("app.tools.expand")} to show full startup help and loaded resources.`);
+            const compactOnboarding = theme.fg("dim", `Press ${keyText("app.tools.expand")} to load session history or show full startup help and loaded resources.`);
             const onboarding = theme.fg("dim", `Pi can explain its own features and look up its docs. Ask it how to use or extend Pi.`);
             this.builtInHeader = new ExpandableText(() => `${logo}\n${compactInstructions}\n${compactOnboarding}\n\n${onboarding}`, () => `${logo}\n${expandedInstructions}\n\n${onboarding}`, this.getStartupExpansionState(), 1, 0);
             // Setup UI layout
@@ -1434,7 +1448,6 @@ export class InteractiveMode {
                     if (result.cancelled) {
                         return { cancelled: true };
                     }
-                    this.chatContainer.clear();
                     await this.renderInitialMessages();
                     if (result.editorText && !this.editor.getText().trim()) {
                         this.editor.setText(result.editorText);
@@ -1502,7 +1515,6 @@ export class InteractiveMode {
         process.exit(1);
     }
     renderCurrentSessionState() {
-        this.chatContainer.clear();
         this.pendingMessagesContainer.clear();
         this.compactionQueuedMessages = [];
         this.streamingComponent = undefined;
@@ -1527,21 +1539,25 @@ export class InteractiveMode {
         const toolGroup = allowGrouping ? component.toolGroup?.trim() : undefined;
         if (!toolGroup) {
             this.chatContainer.addChild(component);
+            this.trimLiveTuiHistory();
             return;
         }
         const children = this.chatContainer.children;
         const lastChild = children[children.length - 1];
         if (lastChild instanceof ToolGroupComponent && lastChild.toolGroup === toolGroup) {
             lastChild.addTool(component);
+            this.trimLiveTuiHistory();
             return;
         }
         if (lastChild instanceof ToolExecutionComponent && lastChild.toolGroup?.trim() === toolGroup) {
             const group = new ToolGroupComponent(toolGroup, [lastChild, component]);
             group.setExpanded(this.toolOutputExpanded);
             children[children.length - 1] = group;
+            this.trimLiveTuiHistory();
             return;
         }
         this.chatContainer.addChild(component);
+        this.trimLiveTuiHistory();
     }
     detachToolExecutionComponent(component) {
         const children = this.chatContainer.children;
@@ -2286,7 +2302,7 @@ export class InteractiveMode {
         // Global debug handler on TUI (works regardless of focus)
         this.ui.onDebug = () => this.handleDebugCommand();
         this.defaultEditor.onAction("app.model.select", () => void this.showModelSelector());
-        this.defaultEditor.onAction("app.tools.expand", () => this.toggleToolOutputExpansion());
+        this.defaultEditor.onAction("app.tools.expand", () => this.loadTuiHistoryOnDemand());
         this.defaultEditor.onAction("app.thinking.toggle", () => void this.toggleThinkingBlockVisibility());
         this.defaultEditor.onAction("app.editor.external", () => this.openExternalEditor());
         this.defaultEditor.onAction("app.message.followUp", () => this.handleFollowUp());
@@ -2623,31 +2639,18 @@ export class InteractiveMode {
                     this.ui.requestRender();
                 }
                 else if (event.message.role === "assistant") {
+                    this.clearPendingStreamingUiUpdate();
+                    this.lastStreamingUiUpdateAt = 0;
                     this.streamingComponent = new AssistantMessageComponent(undefined, this.hideThinkingBlock, this.getMarkdownThemeWithSettings(), this.hiddenThinkingLabel);
                     this.streamingMessage = event.message;
                     this.chatContainer.addChild(this.streamingComponent);
-                    this.streamingComponent.updateContent(this.streamingMessage);
-                    this.ui.requestRender();
+                    this.applyStreamingMessageUpdate(this.streamingMessage, { force: true });
+                    this.trimLiveTuiHistory();
                 }
                 break;
             case "message_update":
                 if (this.streamingComponent && event.message.role === "assistant") {
-                    this.streamingMessage = event.message;
-                    this.streamingComponent.updateContent(this.streamingMessage);
-                    for (const content of this.streamingMessage.content) {
-                        if (content.type === "toolCall") {
-                            if (!this.toolPanels.hasActive(content.id)) {
-                                this.attachToolExecutionComponent(content.name, content.id, content.arguments);
-                            }
-                            else {
-                                const component = this.toolPanels.getActive(content.id);
-                                if (component) {
-                                    component.updateArgs(content.arguments);
-                                }
-                            }
-                        }
-                    }
-                    this.ui.requestRender();
+                    this.applyStreamingMessageUpdate(event.message);
                 }
                 break;
             case "message_end":
@@ -2664,7 +2667,7 @@ export class InteractiveMode {
                                 : "Operation aborted";
                         this.streamingMessage.errorMessage = errorMessage;
                     }
-                    this.streamingComponent.updateContent(this.streamingMessage);
+                    this.applyStreamingMessageUpdate(this.streamingMessage, { force: true });
                     if (this.streamingMessage.stopReason === "aborted" || this.streamingMessage.stopReason === "error") {
                         if (!errorMessage) {
                             errorMessage = this.streamingMessage.errorMessage || "Error";
@@ -2777,7 +2780,6 @@ export class InteractiveMode {
                     }
                 }
                 else if (event.result) {
-                    this.chatContainer.clear();
                     await this.rebuildChatFromMessages();
                     this.addMessageToChat(createCompactionSummaryMessage(event.result.summary, event.result.tokensBefore, new Date().toISOString()));
                     this.footer.invalidate();
@@ -2849,19 +2851,139 @@ export class InteractiveMode {
             : message.content.filter((c) => c.type === "text");
         return textBlocks.map((c) => c.text).join("");
     }
-    /**
-     * Show a status message in the chat.
-     *
-     * If multiple status messages are emitted back-to-back (without anything else being added to the chat),
-     * we update the previous status line instead of appending new ones to avoid log spam.
-     */
-    showStatus(message) {
+    resetLiveTuiHistoryTrim() {
+        this.liveHistoryHiddenNotice = undefined;
+        this.liveHistoryHiddenComponents = 0;
+    }
+    clearPendingStreamingUiUpdate() {
+        if (!this.streamingUiUpdateTimer)
+            return;
+        clearTimeout(this.streamingUiUpdateTimer);
+        this.streamingUiUpdateTimer = undefined;
+    }
+    getSessionEntryCount() {
+        const manager = this.sessionManager;
+        return manager.getEntryCount?.() ?? manager.getEntries().length;
+    }
+    showDeferredHistoryPlaceholder(options = {}) {
+        this.chatContainer.children = [];
+        this.resetLiveTuiHistoryTrim();
+        this.clearRenderedToolPanelState();
+        const entryCount = this.getSessionEntryCount();
+        if (entryCount > 0) {
+            this.chatContainer.addChild(new Text(theme.fg("dim", `History hidden for typing performance (${entryCount} entries). Press ${keyText("app.tools.expand")} to load session history on demand.`), 1, 0));
+        }
+        if (options.requestRender ?? true)
+            this.ui.requestRender();
+    }
+    loadTuiHistoryOnDemand() {
+        if (this.tuiHistoryLoadInProgress)
+            return;
+        if (this.tuiHistoryLoaded || this.getSessionEntryCount() === 0) {
+            this.toggleToolOutputExpansion();
+            return;
+        }
+        this.tuiHistoryLoadInProgress = true;
+        void (async () => {
+            try {
+                await this.renderInitialMessages({ forceHistoryLoad: true });
+            }
+            catch (error) {
+                this.showError(`Failed to load TUI history: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            finally {
+                this.tuiHistoryLoadInProgress = false;
+            }
+        })();
+    }
+    attachStreamingToolPanels(message) {
+        for (const content of message.content) {
+            if (content.type !== "toolCall")
+                continue;
+            if (!this.toolPanels.hasActive(content.id)) {
+                this.attachToolExecutionComponent(content.name, content.id, content.arguments);
+            }
+            else {
+                const component = this.toolPanels.getActive(content.id);
+                if (component) {
+                    component.updateArgs(content.arguments);
+                }
+            }
+        }
+    }
+    applyStreamingMessageUpdate(message, options = {}) {
+        this.streamingMessage = message;
+        if (!this.streamingComponent)
+            return;
+        const now = performance.now();
+        const elapsed = now - this.lastStreamingUiUpdateAt;
+        const hasToolCall = message.content.some((content) => content.type === "toolCall");
+        const shouldUpdateNow = options.force || hasToolCall || elapsed >= STREAMING_UI_UPDATE_INTERVAL_MS;
+        const update = () => {
+            if (!this.streamingComponent || !this.streamingMessage)
+                return;
+            this.streamingComponent.updateContent(this.streamingMessage);
+            this.attachStreamingToolPanels(this.streamingMessage);
+            this.lastStreamingUiUpdateAt = performance.now();
+            this.ui.requestRender();
+        };
+        if (shouldUpdateNow) {
+            this.clearPendingStreamingUiUpdate();
+            update();
+            return;
+        }
+        if (this.streamingUiUpdateTimer)
+            return;
+        this.streamingUiUpdateTimer = setTimeout(() => {
+            this.streamingUiUpdateTimer = undefined;
+            update();
+        }, Math.max(0, STREAMING_UI_UPDATE_INTERVAL_MS - elapsed));
+    }
+    trimLiveTuiHistory() {
+        const children = this.chatContainer.children;
+        if (children.length <= TUI_LIVE_HISTORY_MAX_COMPONENTS)
+            return;
+        let protectedStart = children.length;
+        const protect = (component) => {
+            if (!component)
+                return;
+            const index = children.indexOf(component);
+            if (index !== -1 && index < protectedStart)
+                protectedStart = index;
+        };
+        protect(this.streamingComponent);
+        protect(this.lastStatusSpacer);
+        protect(this.lastStatusText);
+        for (const [, component] of this.toolPanels.activeEntries()) {
+            protect(component);
+        }
+        const trimStart = children[0] === this.liveHistoryHiddenNotice ? 1 : 0;
+        const targetTrimEnd = children.length - TUI_LIVE_HISTORY_TRIM_TO_COMPONENTS;
+        const trimEnd = Math.min(targetTrimEnd, protectedStart);
+        if (trimEnd <= trimStart)
+            return;
+        const removed = children.splice(trimStart, trimEnd - trimStart);
+        this.liveHistoryHiddenComponents += removed.length;
+        if (removed.includes(this.lastStatusSpacer))
+            this.lastStatusSpacer = undefined;
+        if (removed.includes(this.lastStatusText))
+            this.lastStatusText = undefined;
+        const noticeText = theme.fg("dim", `Older TUI history hidden to preserve FPS (${this.liveHistoryHiddenComponents} components). Full session remains available to the model.`);
+        if (children[0] === this.liveHistoryHiddenNotice) {
+            this.liveHistoryHiddenNotice?.setText(noticeText);
+            return;
+        }
+        this.liveHistoryHiddenNotice = new Text(noticeText, 1, 0);
+        children.unshift(this.liveHistoryHiddenNotice);
+    }
+    appendStatusToChat(message, options = {}) {
         const children = this.chatContainer.children;
         const last = children.length > 0 ? children[children.length - 1] : undefined;
         const secondLast = children.length > 1 ? children[children.length - 2] : undefined;
         if (last && secondLast && last === this.lastStatusText && secondLast === this.lastStatusSpacer) {
             this.lastStatusText.setText(theme.fg("dim", message));
-            this.ui.requestRender();
+            if (options.requestRender ?? true)
+                this.ui.requestRender();
             return;
         }
         const spacer = new Spacer(1);
@@ -2870,7 +2992,18 @@ export class InteractiveMode {
         this.chatContainer.addChild(text);
         this.lastStatusSpacer = spacer;
         this.lastStatusText = text;
-        this.ui.requestRender();
+        this.trimLiveTuiHistory();
+        if (options.requestRender ?? true)
+            this.ui.requestRender();
+    }
+    /**
+     * Show a status message in the chat.
+     *
+     * If multiple status messages are emitted back-to-back (without anything else being added to the chat),
+     * we update the previous status line instead of appending new ones to avoid log spam.
+     */
+    showStatus(message) {
+        this.appendStatusToChat(message);
     }
     addMessageToChat(message, options) {
         switch (message.role) {
@@ -2947,6 +3080,117 @@ export class InteractiveMode {
                 const _exhaustive = message;
             }
         }
+        this.trimLiveTuiHistory();
+    }
+    getContentText(content) {
+        if (typeof content === "string")
+            return content;
+        if (Array.isArray(content)) {
+            return content
+                .map((part) => {
+                const maybeText = part.text;
+                return typeof maybeText === "string" ? maybeText : "";
+            })
+                .join("");
+        }
+        return "";
+    }
+    getTuiHistoryMessageText(message) {
+        switch (message.role) {
+            case "bashExecution":
+                return [message.command, message.output ?? ""].filter(Boolean).join("\n");
+            case "user":
+                return this.getUserMessageText(message);
+            case "assistant":
+                return this.getContentText(message.content);
+            case "toolResult":
+                return this.getContentText(message.content);
+            case "custom":
+                return this.getContentText(message.content);
+            case "compactionSummary":
+            case "branchSummary":
+                return message.summary;
+            default: {
+                const _exhaustive = message;
+                return JSON.stringify(_exhaustive);
+            }
+        }
+    }
+    estimateTuiHistoryLines(message) {
+        const text = this.getTuiHistoryMessageText(message);
+        const hardLines = text.length > 0 ? text.split(/\r\n|\r|\n/).length : 1;
+        const wrappedLines = Math.ceil(text.length / TUI_HISTORY_RELOAD_WRAP_WIDTH);
+        // Add one line for role/tool chrome or spacing. Tool-call-only assistant messages
+        // have little text but still render a component.
+        return Math.max(1, hardLines, wrappedLines) + 1;
+    }
+    trimTextToTuiHistoryTail(text, maxEstimatedLines) {
+        const maxLines = Math.max(1, maxEstimatedLines);
+        const lines = text.split(/\r\n|\r|\n/);
+        if (lines.length > maxLines) {
+            const omitted = lines.length - maxLines;
+            return `[Earlier ${omitted} line${omitted === 1 ? "" : "s"} omitted from TUI reload history; full session remains available to the model.]\n${lines.slice(-maxLines).join("\n")}`;
+        }
+        const maxChars = Math.max(TUI_HISTORY_RELOAD_WRAP_WIDTH, maxLines * TUI_HISTORY_RELOAD_WRAP_WIDTH);
+        if (text.length > maxChars) {
+            const omitted = text.length - maxChars;
+            return `[Earlier ${omitted} character${omitted === 1 ? "" : "s"} omitted from TUI reload history; full session remains available to the model.]\n${text.slice(-maxChars)}`;
+        }
+        return text;
+    }
+    trimMessageToTuiHistoryTail(message, maxEstimatedLines) {
+        const text = this.getTuiHistoryMessageText(message);
+        const trimmedText = this.trimTextToTuiHistoryTail(text, maxEstimatedLines);
+        if (trimmedText === text)
+            return message;
+        const clone = JSON.parse(JSON.stringify(message));
+        const mutable = clone;
+        if (mutable.role === "bashExecution" && typeof mutable.output === "string") {
+            mutable.output = trimmedText;
+        }
+        else if (mutable.role === "compactionSummary" || mutable.role === "branchSummary") {
+            mutable.summary = trimmedText;
+        }
+        else if (typeof mutable.content === "string") {
+            mutable.content = trimmedText;
+        }
+        else {
+            mutable.content = [{ type: "text", text: trimmedText }];
+        }
+        return clone;
+    }
+    messagesForTuiHistoryReload(messages) {
+        let estimatedLines = 0;
+        let start = messages.length;
+        for (let i = messages.length - 1; i >= 0; i--) {
+            const nextLines = this.estimateTuiHistoryLines(messages[i]);
+            if (start < messages.length && estimatedLines + nextLines > TUI_HISTORY_RELOAD_MAX_LINES)
+                break;
+            estimatedLines += nextLines;
+            start = i;
+            if (estimatedLines >= TUI_HISTORY_RELOAD_MAX_LINES)
+                break;
+        }
+        const selected = messages.slice(start);
+        if (selected.length > 0 && estimatedLines > TUI_HISTORY_RELOAD_MAX_LINES) {
+            const tailLines = selected.slice(1).reduce((sum, message) => sum + this.estimateTuiHistoryLines(message), 0);
+            const firstAllowance = TUI_HISTORY_RELOAD_MAX_LINES - tailLines;
+            if (firstAllowance <= 4) {
+                selected.shift();
+                start += 1;
+                estimatedLines = tailLines;
+            }
+            else {
+                // Reserve room for truncation marker, role chrome, and wrap variance.
+                selected[0] = this.trimMessageToTuiHistoryTail(selected[0], firstAllowance - 4);
+                estimatedLines = tailLines + this.estimateTuiHistoryLines(selected[0]);
+            }
+        }
+        return {
+            messages: selected,
+            omittedMessages: start,
+            estimatedLines,
+        };
     }
     /**
      * Render session context to chat. Used for initial load and rebuild after compaction.
@@ -2956,77 +3200,123 @@ export class InteractiveMode {
      */
     renderGeneration = 0;
     async renderSessionContext(sessionContext, options = {}) {
-        // Rebuilding a long session's scrollback synchronously blocks the event loop
-        // for seconds (reload/resume feel frozen). Yield between chunks so input and
-        // repaints keep flowing; a newer rebuild supersedes this one via generation.
+        // Build long history offscreen, then atomically swap it into the visible
+        // chat container. This keeps the TUI responsive without flashing blank or
+        // partial transcript frames during resume/reload/compaction rebuilds.
         const generation = ++this.renderGeneration;
-        const CHUNK_SIZE = 20;
         let processed = 0;
+        let committed = false;
+        const visibleChatContainer = this.chatContainer;
+        const previousLiveHistoryHiddenNotice = this.liveHistoryHiddenNotice;
+        const previousLiveHistoryHiddenComponents = this.liveHistoryHiddenComponents;
+        const previousLastStatusSpacer = this.lastStatusSpacer;
+        const previousLastStatusText = this.lastStatusText;
+        const stagingChatContainer = new Container();
+        this.chatContainer = stagingChatContainer;
+        this.resetLiveTuiHistoryTrim();
         this.clearRenderedToolPanelState();
         const renderedPendingTools = new Map();
-        if (options.updateFooter) {
-            this.footer.invalidate();
-            this.updateEditorBorderColor();
-        }
-        for (const message of sessionContext.messages) {
-            if (processed > 0 && processed % CHUNK_SIZE === 0) {
-                this.ui.requestRender();
-                await new Promise((resolve) => setImmediate(resolve));
-                if (generation !== this.renderGeneration)
-                    return;
+        try {
+            if (options.updateFooter) {
+                this.footer.invalidate();
+                this.updateEditorBorderColor();
             }
-            processed++;
-            // Assistant messages need special handling for tool calls
-            if (message.role === "assistant") {
-                this.addMessageToChat(message);
-                // Render tool call components
-                for (const content of message.content) {
-                    if (content.type === "toolCall") {
-                        const component = this.attachToolExecutionComponent(content.name, content.id, content.arguments);
-                        if (message.stopReason === "aborted" || message.stopReason === "error") {
-                            let errorMessage;
-                            if (message.stopReason === "aborted") {
-                                const retryAttempt = this.session.retryAttempt;
-                                errorMessage =
-                                    retryAttempt > 0
-                                        ? `Aborted after ${retryAttempt} retry attempt${retryAttempt > 1 ? "s" : ""}`
-                                        : "Operation aborted";
+            const tuiHistory = this.messagesForTuiHistoryReload(sessionContext.messages);
+            if (tuiHistory.omittedMessages > 0) {
+                this.appendStatusToChat(`Showing last ~${TUI_HISTORY_RELOAD_MAX_LINES} TUI history lines; omitted ${tuiHistory.omittedMessages} older message${tuiHistory.omittedMessages === 1 ? "" : "s"}. Full session remains available to the model.`, { requestRender: false });
+            }
+            for (const message of tuiHistory.messages) {
+                if (processed > 0 && processed % TUI_HISTORY_RELOAD_CHUNK_SIZE === 0) {
+                    await new Promise((resolve) => setImmediate(resolve));
+                    if (generation !== this.renderGeneration)
+                        return;
+                }
+                processed++;
+                // Assistant messages need special handling for tool calls
+                if (message.role === "assistant") {
+                    this.addMessageToChat(message);
+                    // Render tool call components
+                    for (const content of message.content) {
+                        if (content.type === "toolCall") {
+                            const component = this.attachToolExecutionComponent(content.name, content.id, content.arguments);
+                            if (message.stopReason === "aborted" || message.stopReason === "error") {
+                                let errorMessage;
+                                if (message.stopReason === "aborted") {
+                                    const retryAttempt = this.session.retryAttempt;
+                                    errorMessage =
+                                        retryAttempt > 0
+                                            ? `Aborted after ${retryAttempt} retry attempt${retryAttempt > 1 ? "s" : ""}`
+                                            : "Operation aborted";
+                                }
+                                else {
+                                    errorMessage = message.errorMessage || "Error";
+                                }
+                                component.updateResult({ content: [{ type: "text", text: errorMessage }], isError: true });
+                                this.toolPanels.finish(content.id);
                             }
                             else {
-                                errorMessage = message.errorMessage || "Error";
+                                renderedPendingTools.set(content.id, component);
                             }
-                            component.updateResult({ content: [{ type: "text", text: errorMessage }], isError: true });
-                            this.toolPanels.finish(content.id);
-                        }
-                        else {
-                            renderedPendingTools.set(content.id, component);
                         }
                     }
                 }
-            }
-            else if (message.role === "toolResult") {
-                // Match tool results to pending tool components
-                const component = renderedPendingTools.get(message.toolCallId);
-                if (component) {
-                    component.updateResult(message);
-                    renderedPendingTools.delete(message.toolCallId);
-                    this.toolPanels.finish(message.toolCallId);
+                else if (message.role === "toolResult") {
+                    // Match tool results to pending tool components
+                    const component = renderedPendingTools.get(message.toolCallId);
+                    if (component) {
+                        component.updateResult(message);
+                        renderedPendingTools.delete(message.toolCallId);
+                        this.toolPanels.finish(message.toolCallId);
+                    }
                 }
+                else {
+                    // All other messages use standard rendering
+                    this.addMessageToChat(message, options);
+                }
+            }
+            if (generation !== this.renderGeneration)
+                return;
+            visibleChatContainer.children = stagingChatContainer.children;
+            committed = true;
+        }
+        finally {
+            const stagedLiveHistoryHiddenNotice = this.liveHistoryHiddenNotice;
+            const stagedLiveHistoryHiddenComponents = this.liveHistoryHiddenComponents;
+            const stagedLastStatusSpacer = this.lastStatusSpacer;
+            const stagedLastStatusText = this.lastStatusText;
+            this.chatContainer = visibleChatContainer;
+            if (committed) {
+                this.liveHistoryHiddenNotice = stagedLiveHistoryHiddenNotice;
+                this.liveHistoryHiddenComponents = stagedLiveHistoryHiddenComponents;
+                this.lastStatusSpacer = stagedLastStatusSpacer;
+                this.lastStatusText = stagedLastStatusText;
             }
             else {
-                // All other messages use standard rendering
-                this.addMessageToChat(message, options);
+                this.liveHistoryHiddenNotice = previousLiveHistoryHiddenNotice;
+                this.liveHistoryHiddenComponents = previousLiveHistoryHiddenComponents;
+                this.lastStatusSpacer = previousLastStatusSpacer;
+                this.lastStatusText = previousLastStatusText;
             }
         }
-        this.ui.requestRender();
+        if (committed)
+            this.ui.requestRender();
     }
-    async renderInitialMessages() {
-        // Get aligned messages and entries from session context
+    async renderInitialMessages(options = {}) {
+        if (!options.forceHistoryLoad) {
+            this.tuiHistoryLoaded = false;
+            this.showDeferredHistoryPlaceholder({ requestRender: true });
+            this.footer.invalidate();
+            this.updateEditorBorderColor();
+            return;
+        }
+        // Get aligned messages and entries from session context only when the user
+        // explicitly requests TUI history. The model/session state is already loaded.
         const context = this.sessionManager.buildSessionContext();
         await this.renderSessionContext(context, {
             updateFooter: true,
             populateHistory: true,
         });
+        this.tuiHistoryLoaded = true;
         // Show compaction info if session was compacted
         const allEntries = this.sessionManager.getEntries();
         const compactionCount = allEntries.filter((e) => e.type === "compaction").length;
@@ -3048,7 +3338,10 @@ export class InteractiveMode {
         });
     }
     async rebuildChatFromMessages() {
-        this.chatContainer.clear();
+        if (!this.tuiHistoryLoaded) {
+            this.showDeferredHistoryPlaceholder({ requestRender: true });
+            return;
+        }
         const context = this.sessionManager.buildSessionContext();
         await this.renderSessionContext(context);
     }
@@ -3330,7 +3623,6 @@ export class InteractiveMode {
         this.hideThinkingBlock = !this.hideThinkingBlock;
         this.settingsManager.setHideThinkingBlock(this.hideThinkingBlock);
         // Rebuild chat from session messages
-        this.chatContainer.clear();
         await this.rebuildChatFromMessages();
         // If streaming, re-add the streaming component with updated visibility and re-render
         if (this.streamingComponent && this.streamingMessage) {
@@ -4020,16 +4312,16 @@ export class InteractiveMode {
             ? `\n\nLatest completed turn digest (bounded; use only as current-session evidence, not as longitudinal proof):\n<turn_digest>\n${options.turnDigest}\n</turn_digest>`
             : "";
         const objective = options.kind === "reflection"
-            ? "review the latest completed turn for durable memory, skill, validation, and tooling-improvement cues, then run one bounded continuous-learning pass if the learning tools are available"
+            ? "review the latest completed turn for durable memory, skill, validation, tooling, and code-baked self-improvement cues, then run one bounded continuous-learning pass if the learning tools are available"
             : "run one bounded continuous-learning pass for this Pi tenant";
-        return `You are Pi Auto Learn running as a background learner.\n\nObjective: ${objective}.\nTrigger: ${reason}.\n\n${authorityBlock}\n\nRequired workflow:\n1. Query existing durable memory/rules first when tools allow it. Memory confrontation is mandatory before accepting, merging, upgrading, or rejecting learning candidates.\n2. Run the available Auto Learn tooling, preferably learning_run_auto, with applyHighConfidence=${settings.applyHighConfidence}. Process candidate validation in vectorized chunks/batches; avoid scalar per-candidate memory queries except for final selected writes.\n3. Apply the learning validation tree to each candidate chunk: (a) Why is this good for the user? (b) Is it unique, or similar to existing memory/skills/agents so it should merge or upgrade existing knowledge? (c) Will this make Pi a better agent? Candidates that cannot answer all three are noise.\n4. Treat the latest-turn digest as current-session evidence only; do not auto-commit one-off cues unless deterministic tooling and memory confrontation corroborate them.\n5. In mode=full, apply safe memory/skill/user-extension/authorized-source improvements under the standing grant above; otherwise keep them proposal-gated.\n6. Never cross hard-stop boundaries from the authority policy.\n7. If the learning tools are unavailable, report BLOCKED with the missing tool names and do not improvise.\n8. Finish with PASS, BLOCKED, or FAIL and concise evidence, including chunk counts, merge/upgrade decisions, and cleanup/purge status.${reflectionBlock}`;
+        return `You are Pi Auto Learn running as a background learner.\n\nObjective: ${objective}.\nTrigger: ${reason}.\n\n${authorityBlock}\n\nRequired workflow:\n1. Query existing durable memory/rules first when tools allow it. Memory confrontation is mandatory before accepting, merging, upgrading, or rejecting learning candidates.\n2. Run the available Auto Learn tooling, preferably learning_run_auto, with applyHighConfidence=${settings.applyHighConfidence}. Process candidate validation in vectorized chunks/batches; avoid scalar per-candidate memory queries except for final selected writes.\n3. Apply the learning validation tree to each candidate chunk: (a) Why is this good for the user? (b) Is it unique, or similar to existing memory/skills/agents so it should merge or upgrade existing knowledge? (c) Will this make Pi a better agent? Candidates that cannot answer all three are noise.\n4. Hermes-style learning cycle: after a complex task (${AUTO_LEARN_COMPLEX_TASK_TOOL_CALLS}+ tool calls), user correction, repeated steering pattern, non-trivial fix/workaround/debugging path, loaded-skill defect, trigger gap, tool gap, or harness workflow defect, actively create or update durable learning artifacts. Memory stores compact facts/preferences/state; skills/prompts/agents/extensions/source store procedural behavior. When a lesson changes how Pi should act on a future class of task, memory alone is not completion.\n5. Skill update preference order: (1) patch the currently loaded or consulted skill that governed the task; (2) patch an existing class-level umbrella skill/agent/prompt; (3) add a support file under references/, templates/, or scripts/ and add a SKILL.md pointer; (4) create a new class-level umbrella skill only when no existing artifact fits. Never create one-off PR/error/codename/session skills.\n6. Behavioral self-improvement is code-baked by default: prefer the lowest durable executable layer that fixes the behavior — patch an existing skill/prompt/agent/extension/tool, tune an approved setting, or edit the authorized Pi source when source authority is available. Use Automata only for concise facts/evidence pointers that support the baked change.\n7. Do not harden transient or environment-dependent failures into durable behavior: missing binaries, fresh-install package gaps, credentials not configured, path mismatches, one-off task narratives, or negative tool-broken claims should become setup/troubleshooting fixes only when the fix itself is reusable.\n8. Treat the latest-turn digest as current-session evidence only; do not auto-commit one-off cues unless deterministic tooling and memory confrontation corroborate them.\n9. In mode=full, apply safe memory/skill/user-extension/authorized-source improvements under the standing grant above; otherwise keep them proposal-gated.\n10. Never cross hard-stop boundaries from the authority policy.\n11. If the learning tools are unavailable, report BLOCKED with the missing tool names and do not improvise.\n12. Finish with PASS, BLOCKED, or FAIL and concise evidence, including chunk counts, merge/upgrade/code-bake decisions, changed paths/settings, validation, and cleanup/purge status.${reflectionBlock}`;
     }
     reserveAutoLearnRun(params) {
         return this.withAutoLearnStateLock((current) => {
             const now = Date.now();
             const state = this.pruneAutoLearnHistoryFromState(current, now);
             const tenant = this.getAutoLearnTenantKey();
-            if (params.cooldownKind === "reflection") {
+            if (params.cooldownKind === "reflection" && !params.bypassReflectionCooldown) {
                 const lastReflection = state.lastReflectionByTenant?.[tenant] ?? 0;
                 const cooldownMs = params.settings.reflectionCooldownMinutes * 60 * 1000;
                 if (Math.max(0, lastReflection + cooldownMs - now) > 0) {
@@ -4168,6 +4460,7 @@ export class InteractiveMode {
             settings,
             force,
             cooldownKind: options.cooldownKind,
+            bypassReflectionCooldown: options.bypassReflectionCooldown,
             runId,
             modelPattern,
             reason,
@@ -4332,6 +4625,10 @@ export class InteractiveMode {
             .map((message) => this.getAgentMessagePlainText(message))
             .join("\n");
         const correctionSignal = /\b(next time|for future|from now on|remember this|don't|do not|avoid|instead|you should|should have|you forgot|you missed|not what i asked|wrong again)\b/i.test(userText);
+        const behavioralSelfImprovementSignal = /\b(harness|pi|agent|autonomy|autonomous|self[- ]?improv(?:e|ement|ing)?|steer(?:ing)?|trigger(?:s)?|skill(?:s)?|code[- ]?bak(?:e|ed)|bake(?:d)? into code|not (?:automata|memory)|reference agent|hermes)\b/i.test(userText) &&
+            /\b(improve|automatic(?:ally)?|autonomous|trigger|fire|skill|steer|self[- ]?improv(?:e|ement|ing)?|code[- ]?bak(?:e|ed)|bake(?:d)?|too much|less)\b/i.test(userText);
+        const complexTaskSignal = toolCalls >= AUTO_LEARN_COMPLEX_TASK_TOOL_CALLS;
+        const bypassCooldown = correctionSignal || behavioralSelfImprovementSignal || complexTaskSignal;
         const base = { messageCount, contextPercent, cooldownRemainingMs, runningCount, toolCalls };
         if (!settings.enabled)
             return { ...base, shouldRun: false, reason: "disabled" };
@@ -4344,14 +4641,34 @@ export class InteractiveMode {
                 reason: `max tenant learners running (${runningCount}/${settings.maxConcurrentLearners})`,
             };
         }
-        if (cooldownRemainingMs > 0)
+        if (cooldownRemainingMs > 0 && !bypassCooldown) {
             return { ...base, shouldRun: false, reason: "reflection cooldown" };
+        }
+        if (behavioralSelfImprovementSignal) {
+            return {
+                ...base,
+                shouldRun: true,
+                reason: "reflection behavioral self-improvement signal",
+                digest: this.buildAutonomyReviewDigest(messages),
+                bypassCooldown: true,
+            };
+        }
         if (correctionSignal) {
             return {
                 ...base,
                 shouldRun: true,
                 reason: "reflection correction signal",
                 digest: this.buildAutonomyReviewDigest(messages),
+                bypassCooldown: true,
+            };
+        }
+        if (complexTaskSignal) {
+            return {
+                ...base,
+                shouldRun: true,
+                reason: `reflection complex task learning signal (${toolCalls}/${AUTO_LEARN_COMPLEX_TASK_TOOL_CALLS} tool calls)`,
+                digest: this.buildAutonomyReviewDigest(messages),
+                bypassCooldown: true,
             };
         }
         if (autonomy.mode === "full") {
@@ -4395,6 +4712,7 @@ export class InteractiveMode {
             cooldownKind: "reflection",
             promptKind: "reflection",
             turnDigest: decision.digest,
+            bypassReflectionCooldown: decision.bypassCooldown,
         });
         if (!message.startsWith("Auto Learn started"))
             this.showStatus(message);
@@ -4630,7 +4948,6 @@ export class InteractiveMode {
                             child.setHideThinkingBlock(hidden);
                         }
                     }
-                    this.chatContainer.clear();
                     void this.rebuildChatFromMessages();
                 },
                 onCollapseChangelogChange: (collapsed) => {
@@ -5010,7 +5327,6 @@ export class InteractiveMode {
                         return;
                     }
                     // Update UI
-                    this.chatContainer.clear();
                     await this.renderInitialMessages();
                     if (result.editorText && !this.editor.getText().trim()) {
                         this.editor.setText(result.editorText);