@xingjisoft/neutrino 0.1.3 → 0.1.5

package/dist/screens/chat.js

@@ -1,12 +1,19 @@
 import { Screen } from "../terminal/screen.js";
 import { C } from "../colors.js";
-import { loadPrompt, saveSession, } from "../config.js";
+import { findModel, contextCompressionThreshold, loadConfig, normalizeApprovalMode, loadPrompt, saveSession, } from "../config.js";
 import { drawHeader } from "../header.js";
-import { computeInputWindow, cursorFromColumn, drawInputBox, drawScrollbar, wrapText } from "../ui.js";
+import { computeInputWindow, cursorFromColumn, drawInputBox, drawScrollbar, wrapText, approvalToggle, drawApprovalToggle, inRect } from "../ui.js";
 import { drawSpans, renderMarkdownText } from "../markdown.js";
 import { ellipsize, displayWidth } from "../width.js";
-import { LLMClient } from "../llm/client.js";
+import { sanitizeText } from "../sanitize.js";
+import { LLMClient, describeError } from "../llm/client.js";
 import { executeTool, getToolDefinitions } from "../llm/tools.js";
+import { assessToolCall } from "../llm/risk.js";
+import { ApprovalGate, captureApprovalContext, describeApprovalIntent, statedReason } from "../llm/approval.js";
+import { COMPACT_KEEP, COMPACT_MAX_CHARS_PER_MESSAGE, planCompaction, transcriptFor, modelHistory, normalizeContext, } from "../compact.js";
+import { hub, liveApprovalDetails } from "../web/hub.js";
+import { SessionCheckpoint } from "../persistence.js";
+import { writeCrashLog } from "../terminal/restore.js";
 const TOOLS = getToolDefinitions();
 function parseArgs(s) {
     if (!s || !s.trim())
@@ -22,11 +29,15 @@ function parseArgs(s) {
 export class ChatScreen extends Screen {
     initialMessage;
     loadedMessages = null;
+    loadedCwd = null;
     sessionId = null;
     loadedProvider = null;
     loadedModel = null;
     loadedIntensity = null;
     loadedTokens = null;
+    loadedContext = null;
+    loadedApprovalMode = null;
+    approvalMode = "request";
     modelProvider = "DeepSeek";
     model = { name: "deepseek-chat", url: "https://api.deepseek.com/v1", api_key: "", supports_streaming: true };
     intensity = "High";
@@ -34,6 +45,12 @@ export class ChatScreen extends Screen {
     showInfo = false;
     messages = [];
     streamingContent = null;
+    saveError = null;
+    checkpoint = new SessionCheckpoint(() => {
+        const saved = this.writeSession();
+        this.publishLive();
+        return saved;
+    });
     busy = false;
     paused = false;
     queued = null;
@@ -45,6 +62,36 @@ export class ChatScreen extends Screen {
     scrollbarGeom = null;
     lastEscTime = 0;
     initialized = false;
+    // ---- auto context compression ----
+    /** Prompt tokens of the most recent request — the best proxy for how large
+     *  the current context has grown. Reset once the history is compressed. */
+    lastPromptTokens = 0;
+    compressing = false;
+    context = null;
+    expandedContext = false;
+    contextLines = new Set();
+    contextRows = new Set();
+    // ---- collapsible tool output ----
+    /** Message indices whose tool output is expanded (everything starts
+     *  collapsed). */
+    expandedTools = new Set();
+    /** For each line produced by buildLines, the tool message index it belongs
+     *  to, or -1 when it is not part of a tool block. */
+    toolLineIndex = [];
+    /** Terminal row -> tool message index, rebuilt each render for hit-testing. */
+    toolRows = new Map();
+    // ---- web bridge ----
+    liveKey = null;
+    liveDir = process.cwd();
+    // ---- approval gate ---------------------------------------------------
+    /** Non-null while a tool call is waiting for a human decision. */
+    pendingApproval = null;
+    reviewing = null;
+    /** Decisions taken by the gate, keyed by the tool message (survives
+     * context compression, which renumbers the array). */
+    approvals = new Map();
+    /** Hit boxes of the approval card, rebuilt on every render. */
+    approvalButtons = null;
     constructor(initialMessage = "") {
         super();
         this.initialMessage = initialMessage;
@@ -53,6 +100,7 @@ export class ChatScreen extends Screen {
         if (this.initialized)
             return;
         this.initialized = true;
+        this.approvalMode = normalizeApprovalMode(this.loadedApprovalMode ?? loadConfig().approval_mode);
         const st = this.app.state;
         this.modelProvider = this.loadedProvider ?? st.selectedProvider;
         this.model = {
@@ -72,6 +120,11 @@ export class ChatScreen extends Screen {
         for (const m of this.loadedMessages ?? []) {
             this.messages.push(m);
         }
+        this.context = normalizeContext(this.loadedContext, this.messages.filter((m) => m.role !== "system").length);
+        this.liveDir = this.loadedCwd ?? process.cwd();
+        this.checkpoint.register();
+        this.liveKey = hub.register(this);
+        this.publishLive();
         if (this.initialMessage) {
             this.send(this.initialMessage);
         }
@@ -79,11 +132,171 @@ export class ChatScreen extends Screen {
             this.app.render();
         }
     }
+    onDeactivate() {
+        // Never leave the agent awaiting a decision nobody can give.
+        if (this.pendingApproval)
+            this.settleApproval(false);
+        // A turn can continue after returning to the menu. Keep its exit checkpoint
+        // registered until it finishes, including while a tool is still running.
+        if (this.busy)
+            this.save();
+        else
+            this.checkpoint.dispose();
+        hub.unregister(this.liveKey);
+        this.liveKey = null;
+    }
+    // ---- web bridge (see src/web/hub.ts) ---------------------------------
+    liveCwd() {
+        return this.liveDir;
+    }
+    liveConfigure(selection) {
+        if (this.busy || this.pendingApproval) {
+            return { ok: false, error: "pause the current turn before changing models" };
+        }
+        this.modelProvider = selection.provider;
+        this.model = { ...selection.model };
+        this.intensity = selection.intensity;
+        Object.assign(this.app.state, {
+            selectedProvider: this.modelProvider, selectedModelName: this.model.name,
+            selectedModelUrl: this.model.url, selectedModelApiKey: this.model.api_key,
+            selectedModelStreaming: this.model.supports_streaming, selectedIntensity: this.intensity,
+        });
+        const header = this.messages.find((m) => m.role === "system");
+        if (header?.role === "system")
+            header.content = `Model: ${this.modelProvider}/${this.model.name} | Intensity: ${this.intensity}`;
+        this.save();
+        this.app.render();
+        this.publishLive();
+        return { ok: true };
+    }
+    liveMeta() {
+        return {
+            sessionId: this.sessionId,
+            title: this.liveTitle(),
+            provider: this.modelProvider,
+            model: this.model.name,
+            intensity: this.intensity,
+            approvalMode: this.approvalMode,
+            busy: this.busy,
+            paused: this.paused,
+            queued: this.queued,
+            compressing: this.compressing,
+            saveError: this.saveError,
+            tokens: { prompt: this.tokens.prompt, completion: this.tokens.completion },
+            approval: this.pendingApproval
+                ? liveApprovalDetails(this.pendingApproval.tool, this.pendingApproval.args, this.pendingApproval.risk, this.liveDir)
+                : null,
+            reviewing: this.reviewing,
+        };
+    }
+    liveSnapshot(key) {
+        const messages = [];
+        for (const message of this.messages) {
+            if (message.role === "system")
+                continue;
+            if (message.role === "summary") {
+                messages.push({ role: "summary", content: message.content, count: message.count });
+            }
+            else if (message.role === "tool") {
+                messages.push({ role: "tool", name: message.name, arguments: message.arguments, result: message.result });
+            }
+            else {
+                messages.push({ role: message.role, content: message.content });
+            }
+        }
+        return {
+            ...this.liveMeta(),
+            key,
+            cwd: this.liveDir,
+            messages,
+            streamingContent: this.streamingContent,
+            context: this.context,
+        };
+    }
+    livePause() {
+        if (this.paused || (!this.busy && !this.queued))
+            return;
+        this.paused = true;
+        this.turnToken++;
+        // A queued decision would otherwise keep the agent awaiting forever.
+        if (this.pendingApproval)
+            this.settleApproval(false);
+        this.busy = false;
+        this.app.state.isThinking = false;
+        this.retainStreamingContent();
+        this.save();
+        this.app.render();
+        this.publishLive();
+    }
+    liveResume() {
+        if (this.paused)
+            this.togglePause();
+    }
+    /** Answer the pending call from the web UI. */
+    liveApprove(approved) {
+        if (!this.pendingApproval)
+            return false;
+        this.settleApproval(approved);
+        return true;
+    }
+    liveSetApprovalMode(mode) {
+        if (this.approvalMode === mode)
+            return;
+        this.approvalMode = mode;
+        if (this.pendingApproval)
+            this.settleApproval(null);
+        this.save();
+        this.app.render();
+        this.publishLive();
+    }
+    liveSend(text) {
+        if (!text.trim())
+            return;
+        this.send(text);
+        this.publishLive();
+    }
+    liveTitle() {
+        for (const message of this.messages) {
+            if (message.role === "user") {
+                const title = message.content.replace(/\s+/g, " ").trim();
+                return title.length > 80 ? title.slice(0, 80) : title;
+            }
+        }
+        return "";
+    }
+    publishLive() {
+        hub.notify(this.liveKey);
+    }
+    approvalToggleY(height = this.app.height) {
+        // Short terminals need the space above the input for the approval card.
+        return this.pendingApproval && height < 13 ? 1 : height - 5;
+    }
+    /**
+     * The input row is persistent chrome: it is drawn with absolute positioning
+     * and must survive any terminal-side drift (ConPTY reflow, a stray scroll).
+     * Repainting it every frame makes the input area self-healing — the log can
+     * never end up "covering" it.
+     */
+    alwaysRepaintRows() {
+        const h = this.app.height;
+        const rows = [];
+        for (let y = h - 5; y <= h - 1; y++)
+            if (y >= 0)
+                rows.push(y);
+        if (this.pendingApproval && h < 13)
+            rows.push(1);
+        return rows;
+    }
     showsCursor() {
         // The chat input is always focused; a cursor is drawn when it holds text.
         return this.inputValue.length > 0;
     }
     onPaste(text) {
+        if (!text)
+            return;
+        // A pasted tab/ESC would otherwise sit in the input box and be re-emitted
+        // by the renderer on every frame, corrupting the rows around it.
+        text = sanitizeText(text, { singleLine: true });
         if (!text)
             return;
         if (this.showInfo)
@@ -94,6 +307,19 @@ export class ChatScreen extends Screen {
         this.app.render();
     }
     onKey(key) {
+        if (key.ctrl && key.name === "a") {
+            this.liveSetApprovalMode(this.approvalMode === "auto" ? "request" : "auto");
+            return;
+        }
+        // A pending approval is modal: it owns the keyboard until answered.
+        if (this.pendingApproval) {
+            const name = key.name.toLowerCase();
+            if (name === "y" || name === "return")
+                this.settleApproval(true);
+            else if (name === "n" || name === "escape")
+                this.settleApproval(false);
+            return;
+        }
         if (this.showInfo) {
             this.showInfo = false;
             this.app.render();
@@ -184,11 +410,29 @@ export class ChatScreen extends Screen {
             return;
         }
         if (key.ctrl && key.name === "l") {
+            // Clearing starts a fresh conversation; do not overwrite the old history.
+            this.save();
+            if (this.saveError) {
+                this.app.render();
+                return;
+            }
+            this.turnToken++;
+            this.busy = false;
+            this.paused = false;
+            this.queued = null;
+            this.compressing = false;
+            this.app.state.isThinking = false;
+            this.lastPromptTokens = 0;
+            this.sessionId = null;
+            this.context = null;
+            this.expandedContext = false;
             const sysText = this.messages[0] && this.messages[0].role === "system" ? this.messages[0].content : "";
             this.messages = [{ role: "system", content: sysText }];
+            this.expandedTools.clear();
             this.streamingContent = null;
             this.scrollTop = 0;
             this.followBottom = true;
+            this.publishLive();
             this.app.render();
             return;
         }
@@ -208,6 +452,23 @@ export class ChatScreen extends Screen {
         if (ev.type === "click") {
             if (ev.button === 2)
                 return; // right click: no-op in chat
+            if (inRect(ev.x, ev.y, approvalToggle(this.app.width, this.approvalToggleY(), this.approvalMode))) {
+                this.liveSetApprovalMode(this.approvalMode === "auto" ? "request" : "auto");
+                return;
+            }
+            // The approval card floats over the log: test its buttons first.
+            const buttons = this.approvalButtons;
+            if (this.pendingApproval && buttons) {
+                const hit = (r) => ev.y === r.y && ev.x >= r.x && ev.x < r.x + r.w;
+                if (hit(buttons.approve)) {
+                    this.settleApproval(true);
+                    return;
+                }
+                if (hit(buttons.deny)) {
+                    this.settleApproval(false);
+                    return;
+                }
+            }
             // header row: right corner toggles token stats, the rest opens model config
             if (ev.y === 0) {
                 if (ev.x >= this.app.width - 3) {
@@ -235,6 +496,19 @@ export class ChatScreen extends Screen {
                 this.app.render();
                 return;
             }
+            // A click inside the conversation log toggles a tool block open/closed.
+            if (this.contextRows.has(ev.y)) {
+                this.expandedContext = !this.expandedContext;
+                this.followBottom = false;
+                this.scrollTop = Math.min(this.scrollTop, Math.min(...this.contextLines));
+                this.app.render();
+                return;
+            }
+            const tool = this.toolRows.get(ev.y);
+            if (tool !== undefined) {
+                this.toggleTool(tool);
+                return;
+            }
             return;
         }
         if (ev.type === "wheel") {
@@ -276,10 +550,12 @@ export class ChatScreen extends Screen {
             this.turnToken++;
             this.busy = false;
             this.app.state.isThinking = false;
+            this.retainStreamingContent();
             this.save();
         }
         this.app.render();
         this.maybeFlushQueue();
+        this.publishLive();
     }
     maybeFlushQueue() {
         if (this.queued) {
@@ -292,9 +568,12 @@ export class ChatScreen extends Screen {
         if (!trimmed)
             return;
         this.messages.push({ role: "user", content: trimmed });
+        // Create the history entry before requesting a model or executing tools.
+        this.save();
         this.inputValue = "";
         this.cursor = 0;
         this.followBottom = true;
+        this.publishLive();
         if (this.busy && !this.paused) {
             this.queued = trimmed;
             this.app.render();
@@ -303,29 +582,77 @@ export class ChatScreen extends Screen {
         this.startTurn();
     }
     startTurn() {
+        const turnMessages = this.messages.slice();
+        const approvalContext = captureApprovalContext(turnMessages);
         this.busy = true;
         this.paused = false;
         this.app.state.isThinking = true;
         const token = ++this.turnToken;
-        const apiMessages = this.buildApiMessages();
         this.streamingContent = "";
         this.app.render();
-        void this.agentLoop(apiMessages, token);
+        this.publishLive();
+        void (async () => {
+            // Shrink the history before building the request when it has outgrown the
+            // configured budget.
+            await this.autoCompress(token);
+            if (token !== this.turnToken)
+                return;
+            const apiMessages = this.buildApiMessages(turnMessages);
+            await this.agentLoop(apiMessages, token, approvalContext);
+        })().catch((err) => {
+            if (token === this.turnToken)
+                this.failTurn(err);
+        });
+    }
+    /**
+     * Ends a turn that failed before or around the agent loop.
+     *
+     * The turn body is a floating promise, so anything thrown outside the loop's
+     * own try/catch would otherwise surface as an unhandled rejection, which Node
+     * turns into a fatal error. Ending the turn here keeps the app alive and the
+     * failure visible in the transcript.
+     */
+    failTurn(err) {
+        this.retainStreamingContent();
+        this.messages.push({ role: "assistant", content: `[Error: ${describeError(err)}]` });
+        this.streamingContent = null;
+        try {
+            this.onTurnFinished();
+        }
+        catch {
+            // If even the cleanup fails, force the idle state so the UI stays usable.
+            this.busy = false;
+            this.paused = false;
+            this.app.state.isThinking = false;
+            try {
+                this.app.render();
+            }
+            catch {
+                // The app-level render guard reports this one.
+            }
+        }
     }
-    buildApiMessages() {
+    buildApiMessages(messages = this.messages) {
         const api = [{ role: "system", content: loadPrompt() }];
-        for (const m of this.messages) {
+        for (const m of modelHistory(messages, this.context)) {
             if (m.role === "user" || m.role === "assistant") {
                 api.push({ role: m.role, content: m.content });
             }
+            else if (m.role === "summary") {
+                // A compressed summary is fed back to the model as its own prior output.
+                api.push({ role: "assistant", content: m.content });
+            }
         }
         return api;
     }
-    async agentLoop(apiMessages, token) {
+    async agentLoop(apiMessages, token, approvalContext) {
         try {
             while (true) {
                 if (token !== this.turnToken)
                     return;
+                // Keep the payload inside budget during a long single turn: once the
+                // context is too large, drop the body of older tool results.
+                apiMessages = this.trimApiMessages(apiMessages);
                 const client = new LLMClient(this.model, this.modelProvider, this.intensity);
                 let content = "";
                 let hasContent = false;
@@ -338,22 +665,23 @@ export class ChatScreen extends Screen {
                     content += chunk;
                     hasContent = true;
                     this.streamingContent = content;
+                    this.checkpoint.schedule();
                     this.app.render();
+                    this.publishLive();
+                }
+                if (token !== this.turnToken) {
+                    // Pause already retained the partial reply. A stale stream must not
+                    // overwrite the buffer belonging to a newer turn.
+                    return;
                 }
                 if (client.usage) {
                     this.tokens.prompt += client.usage.prompt;
                     this.tokens.completion += client.usage.completion;
+                    this.lastPromptTokens = client.usage.prompt;
                 }
                 else {
                     this.tokens.completion += Math.max(1, Math.ceil(content.length / 4));
                 }
-                if (token !== this.turnToken) {
-                    if (content)
-                        this.messages.push({ role: "assistant", content });
-                    this.streamingContent = null;
-                    this.app.render();
-                    return;
-                }
                 if (aborted || this.paused) {
                     if (content)
                         this.messages.push({ role: "assistant", content });
@@ -372,6 +700,7 @@ export class ChatScreen extends Screen {
                 if (hasContent)
                     this.messages.push({ role: "assistant", content });
                 this.streamingContent = null;
+                this.save();
                 apiMessages.push({
                     role: "assistant",
                     content,
@@ -387,19 +716,54 @@ export class ChatScreen extends Screen {
                     const args = parseArgs(tc.arguments);
                     const toolMsg = { role: "tool", name: tc.name, arguments: args, result: "" };
                     this.messages.push(toolMsg);
+                    this.save();
+                    this.publishLive();
                     this.app.render();
-                    const result = await executeTool(tc.name, args);
+                    // Risky calls stop here until a human (or the reviewer agent) clears
+                    // them. The loop awaits a promise that the UI resolves.
+                    const decision = await this.requestApproval(tc.name, args, {
+                        ...approvalContext,
+                        context: captureApprovalContext(apiMessages).context,
+                    });
                     if (token !== this.turnToken || this.paused)
                         return;
+                    if (decision.source !== "prompt" && decision.source !== "input") {
+                        this.approvals.set(toolMsg, decision);
+                    }
+                    if (!decision.approved) {
+                        // A malformed request was never shown to anyone, so there is no
+                        // verdict to respect and the right move is a corrected retry.
+                        toolMsg.result =
+                            decision.source === "input"
+                                ? `[Not executed: ${decision.reason}]`
+                                : `[Not executed: approval denied (${decision.source}): ${decision.reason}] ` +
+                                    describeApprovalIntent(approvalContext) +
+                                    "Do not retry this call unchanged; ask the user how to proceed.";
+                        apiMessages.push({ role: "tool", tool_call_id: tc.id, content: toolMsg.result });
+                        this.save();
+                        this.publishLive();
+                        this.app.render();
+                        continue;
+                    }
+                    const result = await executeTool(tc.name, args, this.liveDir);
+                    // A clear starts a different transcript while an old tool may finish.
+                    if (!this.messages.includes(toolMsg))
+                        return;
                     toolMsg.result = result;
+                    this.save();
+                    if (token !== this.turnToken || this.paused)
+                        return;
                     apiMessages.push({ role: "tool", tool_call_id: tc.id, content: result });
+                    this.publishLive();
                     this.app.render();
                 }
             }
             this.onTurnFinished();
         }
         catch (e) {
-            const err = e instanceof Error ? e.message : String(e);
+            if (token !== this.turnToken)
+                return;
+            const err = describeError(e);
             this.messages.push({ role: "assistant", content: (this.streamingContent ?? "") + `\n[Error: ${err}]` });
             this.streamingContent = null;
             this.onTurnFinished();
@@ -412,52 +776,371 @@ export class ChatScreen extends Screen {
         this.save();
         this.app.render();
         this.maybeFlushQueue();
+        this.publishLive();
+        if (!this.busy && !this.liveKey)
+            this.checkpoint.dispose();
+        // After the queue flush: a queued prompt that took over immediately is not
+        // the end of the user's work, and ringing then would be a false alarm.
+        // Hosts are stubbed in tests, hence the optional call.
+        if (!this.busy)
+            this.app.bell?.("turn");
     }
-    save() {
-        const chatMessages = this.messages.filter((m) => m.role === "user" || m.role === "assistant" || m.role === "tool");
-        if (chatMessages.length === 0)
+    // ---- approval gate ---------------------------------------------------
+    /** Classify a tool call and, when it is risky, run it past the gate. */
+    async requestApproval(tool, args, context = captureApprovalContext(this.messages)) {
+        const risk = assessToolCall(tool, args, this.liveDir);
+        if (!risk)
+            return { approved: true, source: "prompt", reason: "routine call" };
+        const gate = new ApprovalGate({
+            askHuman: () => this.askHuman(tool, args, risk),
+            reviewer: () => this.reviewerModel(),
+            autoApprovalEnabled: () => this.approvalMode === "auto",
+            extremeAutoApprovalEnabled: () => loadConfig().auto_approve_extreme_risk === true,
+            // Reviews happen before any card is shown, so without this the app looks
+            // frozen while the independent assessments run.
+            onReview: (info) => {
+                this.reviewing = info ? {
+                    total: info.total, round: info.round ?? 1, rounds: info.rounds ?? 1,
+                    request: liveApprovalDetails(tool, args, risk, this.liveDir),
+                } : null;
+                this.publishLive();
+                if (!info) {
+                    this.app.showToast("");
+                    return;
+                }
+                // Delete-class calls are reviewed from scratch three times; name the round
+                // so a long wait does not look like a hang.
+                const rounds = info.rounds ?? 1;
+                const which = rounds > 1 ? `round ${info.round ?? 1} of ${rounds}, ` : "";
+                this.app.showToast(`independent review running (${which}${info.total} reviewer${info.total > 1 ? "s" : ""})...`);
+            },
+        });
+        return gate.decide({ tool, args, cwd: this.liveDir, ...context, risk });
+    }
+    /** Park the turn until the user answers; the header turns orange meanwhile. */
+    askHuman(tool, args, risk) {
+        return new Promise((resolve) => {
+            this.pendingApproval = { tool, args, risk, resolve };
+            this.app.state.approval = { tool, level: risk.level };
+            this.app.bell?.("approval");
+            this.app.render();
+            this.publishLive();
+        });
+    }
+    /** Answer the pending request (keyboard, mouse, or the web UI). */
+    settleApproval(approved) {
+        const pending = this.pendingApproval;
+        if (!pending)
             return;
+        this.pendingApproval = null;
+        this.app.state.approval = null;
+        this.approvalButtons = null;
+        pending.resolve(approved);
+        this.app.render();
+        this.publishLive();
+    }
+    /** Reviewer model: `approval_model` when set, otherwise the chat model. */
+    reviewerModel() {
+        const name = String(loadConfig().approval_model ?? "").trim();
+        const found = name ? findModel(name) : null;
+        if (found)
+            return { model: found.model, provider: found.provider, intensity: this.intensity };
+        return { model: this.model, provider: this.modelProvider, intensity: this.intensity };
+    }
+    /** Orange card listing the pending call and its buttons. */
+    drawApprovalCard(buf, logTop, inputY) {
+        const pending = this.pendingApproval;
+        if (!pending)
+            return;
+        const boxW = Math.max(24, Math.min(buf.width - 2, 78));
+        // A ten-row terminal has no room for the risk line as well, and losing the
+        // buttons under the input would leave the call impossible to answer, so the
+        // card drops the secondary line instead of overflowing.
+        const compact = inputY - logTop + 1 < 6;
+        const boxH = compact ? 5 : 6;
+        const boxX = 1;
+        const boxY = Math.max(logTop, inputY - boxH - 1);
+        buf.fillRect(boxX, boxY, boxW, boxH, { bg: C.orangeBg });
+        buf.drawBox(boxX, boxY, boxW, boxH, { fg: C.orange });
+        // Same treatment as the header: the two read as a single alert.
+        buf.fillRect(boxX + 1, boxY, boxW - 2, 1, { bg: C.orange });
+        buf.writeText(boxX + 2, boxY, "Request Approval", { fg: C.black, bg: C.orange, bold: true });
+        const tag = pending.risk.level === "extreme" ? "EXTREME RISK" : "HIGH RISK";
+        const tagX = boxX + boxW - 2 - tag.length;
+        if (tagX > boxX + 22) {
+            buf.writeText(tagX, boxY, tag, { fg: C.black, bg: C.orange, bold: true });
+        }
+        const summary = sanitizeText(pending.risk.summary, { singleLine: true });
+        buf.writeText(boxX + 2, boxY + 1, ellipsize(summary, boxW - 4), {
+            fg: C.assistant,
+            bg: C.orangeBg,
+        });
+        // Two different claims, kept apart on purpose: "Why" is what the agent says
+        // the call is for, "Flag" is what the risk scan actually detected.
+        const whyLabel = "Why: ";
+        const why = sanitizeText(statedReason(pending.args) ?? "the agent gave no reason", {
+            singleLine: true,
+        });
+        buf.writeText(boxX + 2, boxY + 2, whyLabel, { fg: C.orange, bg: C.orangeBg, bold: true });
+        buf.writeText(boxX + 2 + whyLabel.length, boxY + 2, ellipsize(why, Math.max(0, boxW - 4 - whyLabel.length)), { fg: C.assistant, bg: C.orangeBg });
+        if (!compact) {
+            const flagLabel = "Flag: ";
+            const flag = sanitizeText(pending.risk.reasons[0] ?? "", { singleLine: true });
+            buf.writeText(boxX + 2, boxY + 3, flagLabel, { fg: C.dim, bg: C.orangeBg, bold: true });
+            buf.writeText(boxX + 2 + flagLabel.length, boxY + 3, ellipsize(flag, Math.max(0, boxW - 4 - flagLabel.length)), { fg: C.dim, bg: C.orangeBg });
+        }
+        const approve = "[ Y ] Approve";
+        const deny = "[ N ] Deny";
+        const by = boxY + boxH - 2;
+        const denyX = boxX + 2 + approve.length + 3;
+        buf.writeText(boxX + 2, by, approve, { fg: C.black, bg: C.orange, bold: true });
+        buf.writeText(denyX, by, deny, { fg: C.orange, bg: C.orangeBg, bold: true });
+        this.approvalButtons = {
+            approve: { x: boxX + 2, y: by, w: approve.length },
+            deny: { x: denyX, y: by, w: deny.length },
+        };
+    }
+    /** Expand/collapse the tool block belonging to message `index`. */
+    toggleTool(index) {
+        if (this.expandedTools.has(index))
+            this.expandedTools.delete(index);
+        else
+            this.expandedTools.add(index);
+        this.app.render();
+    }
+    /** Compress at 80% of the current model's context capacity. */
+    compressThreshold() {
+        return contextCompressionThreshold(this.modelProvider, this.model);
+    }
+    /**
+     * Summarise only the model's history. Original messages stay in the transcript
+     * and on disk; the UI folds the summarised prefix until the reader expands it.
+     */
+    async autoCompress(token) {
+        const threshold = this.compressThreshold();
+        if (threshold <= 0 || this.lastPromptTokens < threshold)
+            return;
+        const rest = this.messages.filter((m) => m.role !== "system");
+        const items = modelHistory(this.messages, this.context).map((m) => ({
+            role: m.role,
+            content: m.role === "tool" ? m.result : m.content ?? "",
+            name: m.role === "tool" ? m.name : undefined,
+        }));
+        const plan = planCompaction(items, COMPACT_KEEP);
+        if (!plan)
+            return;
+        const end = rest.length - plan.tail.length;
+        if (end <= (this.context?.end ?? 0))
+            return;
+        const transcript = transcriptFor(plan.head, COMPACT_MAX_CHARS_PER_MESSAGE);
+        this.compressing = true;
+        this.publishLive();
+        this.app.render();
+        const snapshotLen = this.messages.length;
+        let summary = "";
         try {
-            this.sessionId = saveSession(chatMessages, this.model.name, this.modelProvider, this.intensity, process.cwd(), this.sessionId ?? undefined, this.tokens);
+            summary = await this.summarizeTranscript(transcript);
         }
         catch {
-            // ignore save errors
+            summary = "";
+        }
+        this.compressing = false;
+        this.publishLive();
+        if (token !== this.turnToken)
+            return;
+        // Keep the summary boundary tied to this snapshot if a user queued another
+        // message while summarising; retry against the new snapshot next turn.
+        if (this.messages.length !== snapshotLen) {
+            this.app.render();
+            return;
+        }
+        const content = summary
+            ? `[Context summary]\n${summary}`
+            : "Earlier messages are preserved in history, but could not be summarized for this request.";
+        this.context = { end, summary: content };
+        this.expandedContext = false;
+        // The context is small again; its real size is re-learned from the next reply.
+        this.lastPromptTokens = 0;
+        this.save();
+    }
+    /**
+     * Summarise a transcript produced by `transcriptFor`. Split out so tests can
+     * stub it without touching the network.
+     */
+    async summarizeTranscript(transcript) {
+        const client = new LLMClient(this.model, this.modelProvider, this.intensity);
+        const text = await client.summarize(transcript);
+        if (client.usage) {
+            this.tokens.prompt += client.usage.prompt;
+            this.tokens.completion += client.usage.completion;
+        }
+        return text;
+    }
+    /**
+     * Keep the outbound payload within budget during a long single turn: once the
+     * context is over the threshold, blank out all but the most recent tool
+     * results. Their full text stays in the visible log, which is collapsible.
+     */
+    trimApiMessages(apiMessages) {
+        const threshold = this.compressThreshold();
+        if (threshold <= 0 || this.lastPromptTokens < threshold)
+            return apiMessages;
+        const toolIdx = [];
+        for (let i = 0; i < apiMessages.length; i++) {
+            if (apiMessages[i].role === "tool")
+                toolIdx.push(i);
+        }
+        const dropCount = toolIdx.length - COMPACT_KEEP;
+        if (dropCount <= 0)
+            return apiMessages;
+        const copy = apiMessages.slice();
+        for (let k = 0; k < dropCount; k++) {
+            copy[toolIdx[k]] = { ...copy[toolIdx[k]], content: "[tool output omitted to save context]" };
+        }
+        return copy;
+    }
+    retainStreamingContent() {
+        if (this.streamingContent) {
+            this.messages.push({ role: "assistant", content: this.streamingContent });
+        }
+        this.streamingContent = null;
+    }
+    save() {
+        this.checkpoint.flush();
+    }
+    writeSession() {
+        const chatMessages = [];
+        for (const m of this.messages) {
+            if (m.role === "user" || m.role === "assistant" || m.role === "tool") {
+                chatMessages.push(m);
+            }
+            else if (m.role === "summary") {
+                // Persist a compressed summary as a plain assistant message.
+                chatMessages.push({ role: "assistant", content: m.content });
+            }
+        }
+        // Snapshot the partial reply without adding it to the in-memory transcript:
+        // the final reply will replace this snapshot, rather than duplicate it.
+        if (this.streamingContent) {
+            chatMessages.push({ role: "assistant", content: this.streamingContent });
+        }
+        if (chatMessages.length === 0)
+            return true;
+        try {
+            this.sessionId = saveSession(chatMessages, this.model.name, this.modelProvider, this.intensity, this.liveDir, this.sessionId ?? undefined, this.tokens, this.context, this.approvalMode);
+            this.saveError = null;
+            return true;
+        }
+        catch (err) {
+            const detail = describeError(err);
+            if (this.saveError === null)
+                writeCrashLog("save session", err);
+            this.saveError = detail;
+            return false;
         }
     }
     buildLines(width) {
         const lines = [];
-        const pushText = (text, style) => {
-            for (const ln of wrapText(text, width)) {
-                lines.push({ spans: [{ text: ln, style }] });
-            }
+        // Parallel map from rendered line -> owning tool message index (-1 = none),
+        // used to turn a click on any line of a tool block into an expand/collapse.
+        const toolLineIndex = [];
+        const add = (line, tool = -1) => {
+            lines.push(line);
+            toolLineIndex.push(tool);
         };
-        for (const m of this.messages) {
+        const pushText = (text, style, tool = -1) => {
+            for (const ln of wrapText(text, width))
+                add({ spans: [{ text: ln, style }] }, tool);
+        };
+        const pushMarkdown = (text, style) => {
+            for (const ln of renderMarkdownText(text, width, style))
+                add(ln);
+        };
+        const context = normalizeContext(this.context, this.messages.filter((m) => m.role !== "system").length);
+        this.contextLines.clear();
+        let recordIndex = 0;
+        for (let mi = 0; mi < this.messages.length; mi++) {
+            const m = this.messages[mi];
+            let archived = false;
+            if (m.role !== "system") {
+                if (recordIndex === 0 && context) {
+                    this.contextLines.add(lines.length);
+                    add({ spans: [{ text: `${this.expandedContext ? "▾" : "▸"} Earlier conversation (${context.end} messages) — click to ${this.expandedContext ? "collapse" : "expand"}`, style: { fg: C.amber, bold: true } }] });
+                }
+                archived = context !== null && recordIndex < context.end;
+                recordIndex++;
+                if (archived && !this.expandedContext)
+                    continue;
+            }
             if (m.role === "system") {
-                pushText(m.content, { fg: C.dim });
+                pushText(sanitizeText(m.content), { fg: C.dim });
             }
             else if (m.role === "user") {
-                lines.push({ spans: [{ text: "You:", style: { fg: C.accent, bold: true } }] });
-                lines.push(...renderMarkdownText(m.content, width, { fg: C.user }));
-                lines.push({ spans: [] });
+                add({ spans: [{ text: "You:", style: { fg: C.accent, bold: true } }] });
+                pushMarkdown(sanitizeText(m.content), { fg: C.user });
+                add({ spans: [] });
             }
             else if (m.role === "assistant") {
-                lines.push({ spans: [{ text: "Neutrino:", style: { fg: C.accent, bold: true } }] });
-                lines.push(...renderMarkdownText(m.content, width, { fg: C.assistant }));
-                lines.push({ spans: [] });
+                add({ spans: [{ text: "Neutrino:", style: { fg: C.accent, bold: true } }] });
+                pushMarkdown(sanitizeText(m.content), { fg: C.assistant });
+                add({ spans: [] });
+            }
+            else if (m.role === "summary") {
+                add({
+                    spans: [
+                        {
+                            text: `✂ Context compressed (${m.count} earlier messages)`,
+                            style: { fg: C.amber, bold: true },
+                        },
+                    ],
+                });
+                pushText(sanitizeText(m.content), { fg: C.dim });
+                add({ spans: [] });
             }
             else if (m.role === "tool") {
-                lines.push({ spans: [{ text: `⚙ ${m.name}`, style: { fg: C.toolHeader, bold: true } }] });
-                const argText = m.arguments.command ?? m.arguments.path ?? "";
+                // Header + the command/path always show; the (often huge) output body is
+                // collapsed by default and toggled by clicking the block.
+                add({ spans: [{ text: `⚙ ${m.name}`, style: { fg: C.toolHeader, bold: true } }] }, mi);
+                const argText = sanitizeText(m.arguments.command ?? m.arguments.path ?? "", { singleLine: true });
                 if (argText)
-                    lines.push({ spans: [{ text: "  " + argText, style: { fg: C.dim } }] });
-                pushText(m.result || "(no output)", { fg: C.dim });
-                lines.push({ spans: [] });
+                    add({ spans: [{ text: "  " + argText, style: { fg: C.dim } }] }, mi);
+                const decision = this.approvals.get(m);
+                if (decision) {
+                    const verdict = decision.approved ? "approved" : "denied";
+                    add({
+                        spans: [
+                            {
+                                text: `  ${decision.approved ? "✓" : "✗"} ${verdict} by ${decision.source} — ${ellipsize(sanitizeText(decision.reason, { singleLine: true }), Math.max(12, width - 12))}`,
+                                style: { fg: decision.approved ? C.green : C.orange },
+                            },
+                        ],
+                    }, mi);
+                }
+                // Command output routinely carries ANSI colours and tabs; clean it once
+                // so the collapsed line count and the expanded body agree.
+                const body = sanitizeText(m.result || "");
+                if (this.expandedTools.has(mi)) {
+                    pushText(body || "(no output)", { fg: C.dim }, mi);
+                    add({ spans: [{ text: "  ▾ click to collapse", style: { fg: C.toolHeader } }] }, mi);
+                }
+                else {
+                    const n = body ? body.split("\n").length : 0;
+                    const summary = n > 0 ? `${n} line${n === 1 ? "" : "s"} hidden` : "no output";
+                    add({ spans: [{ text: `  ▸ ${summary} — click to expand`, style: { fg: C.dim } }] }, mi);
+                }
+                add({ spans: [] });
+            }
+            if (context && archived && recordIndex === context.end) {
+                this.contextLines.add(lines.length);
+                add({ spans: [{ text: "▾ Collapse earlier conversation", style: { fg: C.amber } }] });
+                add({ spans: [] });
             }
         }
         if (this.streamingContent !== null) {
-            lines.push({ spans: [{ text: "Neutrino:", style: { fg: C.accent, bold: true } }] });
-            lines.push(...renderMarkdownText(this.streamingContent, width, { fg: C.assistant }));
+            add({ spans: [{ text: "Neutrino:", style: { fg: C.accent, bold: true } }] });
+            pushMarkdown(sanitizeText(this.streamingContent), { fg: C.assistant });
         }
+        this.toolLineIndex = toolLineIndex;
         return lines;
     }
     render(buf) {
@@ -466,7 +1149,15 @@ export class ChatScreen extends Screen {
         const h = buf.height;
         let status = "";
         let statusStyle = { fg: C.dim };
-        if (this.queued) {
+        if (this.saveError) {
+            status = `History save failed: ${sanitizeText(this.saveError, { singleLine: true })}`;
+            statusStyle = { fg: C.orange, bold: true };
+        }
+        else if (this.compressing) {
+            status = "Compressing context…";
+            statusStyle = { fg: C.amber, bold: true };
+        }
+        else if (this.queued) {
             status = "Will send when paused or idle...";
             statusStyle = { fg: C.amber };
         }
@@ -478,7 +1169,7 @@ export class ChatScreen extends Screen {
             status = "Streaming... press ESC ESC to pause";
             statusStyle = { fg: C.dim };
         }
-        if (status)
+        if (status && this.approvalToggleY(h) !== 1)
             buf.centerText(1, status.slice(0, w), statusStyle);
         const inputY = h - 4;
         const logTop = 2;
@@ -500,16 +1191,30 @@ export class ChatScreen extends Screen {
             lines.length > viewH
                 ? { x: w - 1, top: logTop, bottom: logBottom, total: lines.length, viewport: viewH }
                 : null;
+        // Remember which tool block (if any) each visible row belongs to, so a
+        // click can expand/collapse it (see the onMouse handler).
+        this.toolRows.clear();
+        this.contextRows.clear();
         for (let y = logTop; y <= logBottom; y++) {
             const li = this.scrollTop + (y - logTop);
             if (li >= lines.length)
                 break;
+            const tool = this.toolLineIndex[li];
+            if (tool !== undefined && tool >= 0)
+                this.toolRows.set(y, tool);
+            if (this.contextLines.has(li))
+                this.contextRows.add(y);
             drawSpans(buf, 2, y, lines[li].spans, Math.max(4, w - 4));
         }
         // A scrollbar on the right edge of the log, shown only when the
         // conversation overflows the visible area.
         drawScrollbar(buf, w - 1, logTop, logBottom, lines.length, viewH, this.scrollTop);
+        if (this.pendingApproval)
+            this.drawApprovalCard(buf, logTop, inputY);
+        else
+            this.approvalButtons = null;
         const inW = Math.max(12, w - 2);
+        drawApprovalToggle(buf, this.approvalToggleY(h), this.approvalMode);
         drawInputBox(buf, 1, inputY, inW, this.inputValue, this.cursor, {
             active: true,
             dimmed: this.busy,
@@ -517,7 +1222,7 @@ export class ChatScreen extends Screen {
             placeholder: "Type a message...",
         });
         const hintY = h - 1;
-        const hints = "Enter send · ESC ESC pause · Ctrl+B menu · Ctrl+L clear · drag to copy";
+        const hints = "Enter send · ESC ESC pause · Ctrl+A approval · Ctrl+B menu · Ctrl+L clear · drag to copy";
         const hintW = displayWidth(hints);
         const hintX = Math.max(0, w - 1 - hintW);
         const pathAvail = Math.max(0, hintX - 2);