@xingjisoft/neutrino 0.1.4 → 0.1.6

package/dist/screens/chat.js

@@ -1,15 +1,28 @@
 import { Screen } from "../terminal/screen.js";
 import { C } from "../colors.js";
-import { loadConfig, 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 { sanitizeText } from "../sanitize.js";
 import { LLMClient, describeError } from "../llm/client.js";
 import { executeTool, getToolDefinitions } from "../llm/tools.js";
-import { COMPACT_KEEP, COMPACT_MAX_CHARS_PER_MESSAGE, planCompaction, transcriptFor, } from "../compact.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();
+/**
+ * A finished turn only folds into a one-line summary when hiding it saves real
+ * space: four or more visible blocks, or roughly six wrapped lines of text.
+ * Short exchanges stay readable without a click. `web/turns.js` applies the
+ * same rule in the browser, so both UIs fold exactly the same turns.
+ */
+export const TURN_FOLD_MIN_BLOCKS = 4;
+export const TURN_FOLD_MIN_CHARS = 600;
 function parseArgs(s) {
     if (!s || !s.trim())
         return {};
@@ -24,11 +37,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";
@@ -36,6 +53,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;
@@ -52,6 +75,10 @@ export class ChatScreen extends Screen {
      *  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). */
@@ -61,6 +88,31 @@ export class ChatScreen extends Screen {
     toolLineIndex = [];
     /** Terminal row -> tool message index, rebuilt each render for hit-testing. */
     toolRows = new Map();
+    // ---- collapsible turns ----
+    /** First message index of every turn whose reply has finished. A transcript
+     *  loaded from disk starts finished: reopening history reviews past work. */
+    finishedTurns = new Set();
+    /** Turns the reader opened; a finished turn stays folded unless listed here. */
+    expandedTurns = new Set();
+    /** First message index of the turn being answered right now, if any. */
+    activeTurnStart = null;
+    /** For each built line, the folded turn it belongs to (-1 = none). Only the
+     *  header lines carry it, so clicks inside a tool block still target the tool. */
+    turnLineIndex = [];
+    /** Terminal row -> folded turn start, rebuilt each render for hit-testing. */
+    turnRows = 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;
@@ -69,6 +121,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 = {
@@ -88,6 +141,14 @@ export class ChatScreen extends Screen {
         for (const m of this.loadedMessages ?? []) {
             this.messages.push(m);
         }
+        // Everything already on disk was answered, so history opens compact.
+        for (const start of this.userMessageIndexes())
+            this.finishedTurns.add(start);
+        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);
         }
@@ -95,6 +156,145 @@ 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).
@@ -107,6 +307,8 @@ export class ChatScreen extends Screen {
         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() {
@@ -129,6 +331,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();
@@ -219,12 +434,32 @@ 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.finishedTurns.clear();
+            this.expandedTurns.clear();
+            this.activeTurnStart = null;
             this.streamingContent = null;
             this.scrollTop = 0;
             this.followBottom = true;
+            this.publishLive();
             this.app.render();
             return;
         }
@@ -244,6 +479,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) {
@@ -272,6 +524,18 @@ export class ChatScreen extends Screen {
                 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 turn = this.turnRows.get(ev.y);
+            if (turn !== undefined) {
+                this.toggleTurn(turn);
+                return;
+            }
             const tool = this.toolRows.get(ev.y);
             if (tool !== undefined) {
                 this.toggleTool(tool);
@@ -318,10 +582,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) {
@@ -334,9 +600,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();
@@ -345,25 +614,67 @@ export class ChatScreen extends Screen {
         this.startTurn();
     }
     startTurn() {
+        // Sending closes every earlier turn, including one left unfinished by
+        // ESC ESC: it is folded from here on, but never while it is still paused.
+        const starts = this.userMessageIndexes();
+        const active = starts.length > 0 ? starts[starts.length - 1] : null;
+        for (const start of starts)
+            if (start !== active)
+                this.finishedTurns.add(start);
+        this.activeTurnStart = active;
+        const turnMessages = this.messages.slice();
+        const approvalContext = captureApprovalContext(turnMessages);
         this.busy = true;
         this.paused = false;
         this.app.state.isThinking = true;
         const token = ++this.turnToken;
         this.streamingContent = "";
         this.app.render();
+        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();
-            await this.agentLoop(apiMessages, token);
-        })();
+            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 });
             }
@@ -374,7 +685,7 @@ export class ChatScreen extends Screen {
         }
         return api;
     }
-    async agentLoop(apiMessages, token) {
+    async agentLoop(apiMessages, token, approvalContext) {
         try {
             while (true) {
                 if (token !== this.turnToken)
@@ -394,7 +705,14 @@ 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;
@@ -404,19 +722,12 @@ export class ChatScreen extends Screen {
                 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 });
                     this.streamingContent = null;
                     this.app.render();
-                    this.onTurnFinished();
+                    this.onTurnFinished(false);
                     return;
                 }
                 const toolCalls = client.toolCalls;
@@ -429,6 +740,7 @@ export class ChatScreen extends Screen {
                 if (hasContent)
                     this.messages.push({ role: "assistant", content });
                 this.streamingContent = null;
+                this.save();
                 apiMessages.push({
                     role: "assistant",
                     content,
@@ -444,31 +756,301 @@ 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) {
+            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();
         }
     }
-    onTurnFinished() {
+    /**
+     * Ends the turn. `finished` is false when the turn was cut short (ESC ESC,
+     * Ctrl+C): a paused turn is not a completed one and stays open for reading.
+     */
+    onTurnFinished(finished = true) {
+        if (finished && this.activeTurnStart !== null)
+            this.finishedTurns.add(this.activeTurnStart);
+        this.activeTurnStart = null;
         this.busy = false;
         this.paused = false;
         this.app.state.isThinking = false;
         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");
+    }
+    // ---- 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 },
+        };
+    }
+    // ---- turn folding ----------------------------------------------------
+    /** First message index of every turn: a turn starts at a user message and
+     *  ends where the next one begins. */
+    userMessageIndexes() {
+        const starts = [];
+        for (let i = 0; i < this.messages.length; i++) {
+            if (this.messages[i].role === "user")
+                starts.push(i);
+        }
+        return starts;
+    }
+    turnEnd(start) {
+        for (let i = start + 1; i < this.messages.length; i++) {
+            if (this.messages[i].role === "user")
+                return i;
+        }
+        return this.messages.length;
+    }
+    /**
+     * A finished turn is only worth folding when it hides something substantial.
+     * Whether it is folded right now is a separate question (`expandedTurns`).
+     */
+    turnHides(start, end) {
+        if (!this.finishedTurns.has(start))
+            return false;
+        let blocks = 0;
+        let chars = 0;
+        for (let i = start; i < end; i++) {
+            const m = this.messages[i];
+            if (m.role === "user" || m.role === "assistant") {
+                blocks++;
+                chars += m.content.length;
+            }
+        }
+        return blocks >= TURN_FOLD_MIN_BLOCKS || chars >= TURN_FOLD_MIN_CHARS;
+    }
+    /** For every message, the first index of the turn folding it (-1 = none). */
+    turnMap() {
+        const map = new Array(this.messages.length).fill(-1);
+        for (const start of this.userMessageIndexes()) {
+            const end = this.turnEnd(start);
+            if (!this.turnHides(start, end))
+                continue;
+            for (let i = start; i < end; i++)
+                map[i] = start;
+        }
+        return map;
+    }
+    /**
+     * The first line of the first message in `role` (the last one with `last`).
+     * Only one line: the preview is a signpost, and the full text is a click away.
+     */
+    turnPreview(start, end, role, last = false) {
+        const slice = this.messages.slice(start, end);
+        for (const m of last ? slice.reverse() : slice) {
+            if (m.role !== role)
+                continue;
+            const line = sanitizeText(m.content)
+                .split("\n")
+                .map((part) => part.trim())
+                .find((part) => part.length > 0);
+            if (line)
+                return line;
+        }
+        return "";
+    }
+    /** The header standing in for a folded turn, or the way back into one. */
+    pushTurnHeader(start, end, width, add) {
+        const count = end - start;
+        if (this.expandedTurns.has(start)) {
+            // Open: the messages below say everything, so the line is only the way
+            // back. Reserve the room the hint needs so a narrow terminal keeps it.
+            const hint = " — click to collapse";
+            const label = `▾ ${count} message${count === 1 ? "" : "s"}`;
+            add({
+                spans: [
+                    { text: ellipsize(label, Math.max(10, width - displayWidth(hint))), style: { fg: C.dim, bold: true } },
+                    { text: hint, style: { fg: C.dim } },
+                ],
+            }, -1, start);
+            return;
+        }
+        const you = `You: ${this.turnPreview(start, end, "user") || "(no text)"}`;
+        add({ spans: [{ text: ellipsize(`▸ ${you}`, width), style: { fg: C.amber, bold: true } }] }, -1, start);
+        const reply = this.turnPreview(start, end, "assistant", true);
+        const meta = `${count} message${count === 1 ? "" : "s"} folded`;
+        add({
+            spans: [
+                {
+                    text: ellipsize(`  ${meta}${reply ? ` · Neutrino: ${reply}` : ""} — click to expand`, width),
+                    style: { fg: C.dim },
+                },
+            ],
+        }, -1, start);
+    }
+    /** Fold or unfold one turn. */
+    toggleTurn(start) {
+        if (this.expandedTurns.has(start))
+            this.expandedTurns.delete(start);
+        else
+            this.expandedTurns.add(start);
+        // Expanding pushes the rest of the log down, so do not snap to the bottom.
+        this.followBottom = false;
+        this.app.render();
     }
     /** Expand/collapse the tool block belonging to message `index`. */
     toggleTool(index) {
@@ -478,35 +1060,33 @@ export class ChatScreen extends Screen {
             this.expandedTools.add(index);
         this.app.render();
     }
-    /** Auto-compress threshold in (estimated) prompt tokens; 0 means "off". */
+    /** Compress at 80% of the current model's context capacity. */
     compressThreshold() {
-        const raw = loadConfig().context_compress_threshold;
-        const n = typeof raw === "number" ? raw : Number(raw);
-        return Number.isFinite(n) && n >= 0 ? n : 0;
+        return contextCompressionThreshold(this.modelProvider, this.model);
     }
     /**
-     * Once the context has grown past the configured threshold, replace the older
-     * part of the conversation with a model-written summary. Runs at the start of
-     * a turn, before the request is built. If summarising fails the old messages
-     * are simply dropped, so the context always shrinks.
+     * 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 system = this.messages.find((m) => m.role === "system");
         const rest = this.messages.filter((m) => m.role !== "system");
-        const items = rest.map((m) => ({
+        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,
-            ref: m,
         }));
         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 = "";
@@ -517,23 +1097,20 @@ export class ChatScreen extends Screen {
             summary = "";
         }
         this.compressing = false;
+        this.publishLive();
         if (token !== this.turnToken)
             return;
-        // A new message (queued by the user while we were summarising) would be
-        // dropped by the swap below, so bail out and retry on the next turn.
+        // 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 count = plan.head.length;
         const content = summary
-            ? `[Context compressed]\n${summary}`
-            : `[Context compressed]\n(${count} earlier messages were omitted to free up context.)`;
-        const summaryMsg = { role: "summary", content, count };
-        const kept = plan.tail.map((i) => i.ref);
-        this.messages = system ? [system, summaryMsg, ...kept] : [summaryMsg, ...kept];
-        // Message indices shifted, so any expanded tool block no longer lines up.
-        this.expandedTools.clear();
+            ? `[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();
@@ -574,7 +1151,16 @@ export class ChatScreen extends Screen {
         }
         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") {
@@ -585,13 +1171,24 @@ export class ChatScreen extends Screen {
                 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;
+            return true;
         try {
-            this.sessionId = saveSession(chatMessages, this.model.name, this.modelProvider, this.intensity, process.cwd(), this.sessionId ?? undefined, this.tokens);
+            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 {
-            // ignore save errors
+        catch (err) {
+            const detail = describeError(err);
+            if (this.saveError === null)
+                writeCrashLog("save session", err);
+            this.saveError = detail;
+            return false;
         }
     }
     buildLines(width) {
@@ -599,9 +1196,13 @@ export class ChatScreen extends Screen {
         // 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) => {
+        // Same idea for a folded turn. Only its header lines point at the turn, so
+        // the messages of an expanded turn keep their own click targets.
+        const turnLineIndex = [];
+        const add = (line, tool = -1, turn = -1) => {
             lines.push(line);
             toolLineIndex.push(tool);
+            turnLineIndex.push(turn);
         };
         const pushText = (text, style, tool = -1) => {
             for (const ln of wrapText(text, width))
@@ -611,11 +1212,36 @@ export class ChatScreen extends Screen {
             for (const ln of renderMarkdownText(text, width, style))
                 add(ln);
         };
+        const context = normalizeContext(this.context, this.messages.filter((m) => m.role !== "system").length);
+        // Which turn owns each message: [] -> first index of that turn, -1 = none.
+        const turns = this.turnMap();
+        this.contextLines.clear();
+        let recordIndex = 0;
         for (let mi = 0; mi < this.messages.length; mi++) {
             const m = this.messages[mi];
+            const turn = m.role === "system" ? -1 : turns[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++;
+            }
+            // A foldable turn always shows its control line first; its messages then
+            // render normally when the reader has opened it.
+            if (m.role !== "system" && turn === mi && !(archived && !this.expandedContext)) {
+                this.pushTurnHeader(mi, this.turnEnd(mi), width, add);
+            }
             if (m.role === "system") {
                 pushText(sanitizeText(m.content), { fg: C.dim });
             }
+            else if ((archived && !this.expandedContext) || (turn >= 0 && !this.expandedTurns.has(turn))) {
+                // Hidden, by the collapsed "Earlier conversation" fold or by the turn's
+                // own fold. Either way the message stays in the transcript, on disk and
+                // in the request; the header above says how to get it back on screen.
+            }
             else if (m.role === "user") {
                 add({ spans: [{ text: "You:", style: { fg: C.accent, bold: true } }] });
                 pushMarkdown(sanitizeText(m.content), { fg: C.user });
@@ -645,6 +1271,18 @@ export class ChatScreen extends Screen {
                 const argText = sanitizeText(m.arguments.command ?? m.arguments.path ?? "", { singleLine: true });
                 if (argText)
                     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 || "");
@@ -659,12 +1297,18 @@ export class ChatScreen extends Screen {
                 }
                 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) {
             add({ spans: [{ text: "Neutrino:", style: { fg: C.accent, bold: true } }] });
             pushMarkdown(sanitizeText(this.streamingContent), { fg: C.assistant });
         }
         this.toolLineIndex = toolLineIndex;
+        this.turnLineIndex = turnLineIndex;
         return lines;
     }
     render(buf) {
@@ -673,7 +1317,11 @@ export class ChatScreen extends Screen {
         const h = buf.height;
         let status = "";
         let statusStyle = { fg: C.dim };
-        if (this.compressing) {
+        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 };
         }
@@ -686,10 +1334,10 @@ export class ChatScreen extends Screen {
             statusStyle = { fg: C.amber, bold: true };
         }
         else if (this.busy) {
-            status = "Streaming... press ESC ESC to pause";
+            status = "Streaming... press Ctrl+C or 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;
@@ -714,6 +1362,8 @@ export class ChatScreen extends Screen {
         // 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();
+        this.turnRows.clear();
         for (let y = logTop; y <= logBottom; y++) {
             const li = this.scrollTop + (y - logTop);
             if (li >= lines.length)
@@ -721,12 +1371,22 @@ export class ChatScreen extends Screen {
             const tool = this.toolLineIndex[li];
             if (tool !== undefined && tool >= 0)
                 this.toolRows.set(y, tool);
+            const turn = this.turnLineIndex[li];
+            if (turn !== undefined && turn >= 0)
+                this.turnRows.set(y, turn);
+            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,
@@ -734,7 +1394,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 · Ctrl+C pause · 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);