@xingjisoft/neutrino 0.6.0 → 0.7.0

package/dist/screens/chat.js

@@ -1,4 +1,10 @@
+import { terminalTemplate } from "../plugins/terminal.js";
+import { runPluginTurn, pluginCommand, pluginApprovalContext } from "../plugins/session.js";
 import path from "node:path";
+import { ApprovalQueue } from "../web/approvalQueue.js";
+import { randomUUID } from "node:crypto";
+import { FastAgentEngine } from "../fast/engine.js";
+import { FAST_MODE, assertFastAvailable, fastSettings } from "../fast/types.js";
 import { Screen } from "../terminal/screen.js";
 import { C } from "../colors.js";
 import { findModel, findConfiguredModel, intensityForModel, contextCompressionThreshold, modelContextWindow, sessionDir, loadConfig, loadPlannerPrompt, loadStepPrompt, loadSubAgentPrompt, normalizeApprovalMode, planFirstEnabled, loadAgentPrompt, normalizeAgentMode, saveSession, } from "../config.js";
@@ -7,7 +13,7 @@ import { computeInputWindow, cursorFromColumn, drawInputBox, drawScrollbar, wrap
 import { drawSpans, renderMarkdownText } from "../markdown.js";
 import { ellipsize, displayWidth } from "../width.js";
 import { sanitizeText } from "../sanitize.js";
-import { TaskRuntime, currentTask, linkSignals, taskLimits, resumeTaskSnapshot } from "../llm/runtime.js";
+import { TaskRuntime, TaskControlError, currentTask, linkSignals, taskLimits, taskBudgetScope, resumeTaskSnapshot } from "../llm/runtime.js";
 import { prepareContext, outputAllowance, finalTaskReport } from "../llm/context.js";
 import { settlePlan } from "../llm/plan.js";
 import { LLMClient, describeError } from "../llm/client.js";
@@ -21,12 +27,10 @@ import { COMPACT_KEEP, COMPACT_MAX_CHARS_PER_MESSAGE, planCompaction, transcript
 import { hub, liveApprovalDetails } from "../web/hub.js";
 import { SessionCheckpoint } from "../persistence.js";
 import { writeCrashLog } from "../terminal/restore.js";
-const TOOLS = getToolDefinitions();
 /** A sub-agent gets the same tools minus delegation: one level, never a tree. */
-const SUB_AGENT_TOOLS = getSubAgentToolDefinitions();
 /**
- * A finished turn folds its *work* away — the prompt body, the thinking and the
- * tool calls — and never its final reply, which always stays on screen. Doing
+ * A finished turn folds its *work* away — the thinking and the tool calls —
+ * while the full user prompt and final reply always stay on screen. Doing
  * that is only worth a click when the work is substantial: four or more 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
@@ -84,6 +88,7 @@ export class ChatScreen extends Screen {
     loadedApprovalMode = null;
     loadedPlan = null;
     loadedTask;
+    loadedFast;
     loadedAgentMode = null;
     approvalMode = "request";
     modelProvider = "DeepSeek";
@@ -117,6 +122,8 @@ export class ChatScreen extends Screen {
     turnToken = 0;
     agentMode = "standard";
     activeAgentMode = "standard";
+    fastState;
+    queuedAgentMode = null;
     turnAbort = null;
     inputValue = "";
     cursor = 0;
@@ -161,6 +168,7 @@ export class ChatScreen extends Screen {
     liveDir = process.cwd();
     // ---- approval gate ---------------------------------------------------
     /** Non-null while a tool call is waiting for a human decision. */
+    approvalQueue = new ApprovalQueue();
     pendingApproval = null;
     reviewing = null;
     /** Decisions taken by the gate, keyed by the tool message (survives
@@ -215,6 +223,11 @@ export class ChatScreen extends Screen {
             this.finishedTurns.add(start);
         this.plan = resumePlan(this.loadedPlan);
         this.lastTask = resumeTaskSnapshot(this.loadedTask);
+        this.fastState = this.loadedFast ? structuredClone(this.loadedFast) : undefined;
+        if (this.fastState && !["completed", "failed", "cancelled"].includes(this.fastState.phase)) {
+            this.fastState.phase = "failed";
+            this.fastState.error = "Process restarted; review saved artifacts before resuming. Tools are never replayed automatically.";
+        }
         this.context = normalizeContext(this.loadedContext, this.messages.filter((m) => m.role !== "system").length);
         this.liveDir = this.loadedCwd ?? process.cwd();
         this.checkpoint.register();
@@ -228,6 +241,7 @@ export class ChatScreen extends Screen {
         }
     }
     onDeactivate() {
+        this.approvalQueue.cancelWaiting();
         // Never leave the agent awaiting a decision nobody can give.
         if (this.pendingApproval)
             this.settleApproval(false);
@@ -274,6 +288,7 @@ export class ChatScreen extends Screen {
             approvalMode: this.approvalMode,
             agentMode: this.agentMode,
             activeAgentMode: this.busy ? this.activeAgentMode : this.agentMode,
+            ...(this.fastState ? { fast: this.fastState } : {}),
             task: this.taskRuntime?.snapshot() ?? this.lastTask,
             busy: this.busy,
             paused: this.paused,
@@ -283,7 +298,7 @@ export class ChatScreen extends Screen {
             tokens: { prompt: this.tokens.prompt, completion: this.tokens.completion },
             subagent: this.subagent,
             approval: this.pendingApproval
-                ? liveApprovalDetails(this.pendingApproval.tool, this.pendingApproval.args, this.pendingApproval.risk, this.liveDir)
+                ? { ...liveApprovalDetails(this.pendingApproval.tool, this.pendingApproval.args, this.pendingApproval.risk, this.liveDir), id: this.pendingApproval.id }
                 : null,
             reviewing: this.reviewing,
         };
@@ -316,6 +331,8 @@ export class ChatScreen extends Screen {
     livePause() {
         if (this.paused || (!this.busy && !this.queued))
             return;
+        if (this.fastState && this.activeAgentMode === FAST_MODE && this.busy)
+            this.fastState.phase = "cancelling";
         this.paused = true;
         this.subagent = null;
         this.retryNotice = null;
@@ -339,13 +356,21 @@ export class ChatScreen extends Screen {
             this.togglePause();
     }
     /** Answer the pending call from the web UI. */
-    liveApprove(approved) {
-        if (!this.pendingApproval)
+    liveApprove(approved, approvalId) {
+        if (!this.pendingApproval || (approvalId !== undefined && this.pendingApproval.id !== approvalId))
             return false;
         this.settleApproval(approved);
         return true;
     }
     liveSetAgentMode(mode) {
+        if (mode === FAST_MODE) {
+            try {
+                assertFastAvailable(loadConfig());
+            }
+            catch (error) {
+                return { ok: false, error: describeError(error) };
+            }
+        }
         this.agentMode = mode;
         this.save();
         this.publishLive();
@@ -376,6 +401,8 @@ export class ChatScreen extends Screen {
         this.turnToken++;
         this.taskRuntime = null;
         this.lastTask = undefined;
+        this.fastState = undefined;
+        this.queuedAgentMode = null;
         if (this.pendingApproval)
             this.settleApproval(false);
         this.busy = false;
@@ -738,6 +765,7 @@ export class ChatScreen extends Screen {
         try {
             const client = new LLMClient(this.model, this.modelProvider, this.intensity);
             const answer = await client.complete(loadPlannerPrompt(), buildPlannerInput({ request, cwd: this.liveDir, transcript: planTranscript(this.messages) }), {
+                ...(currentTask()?.runtime.diagnostics ? { diagnostic: { role: "planning" } } : {}),
                 onRetry: (notice) => {
                     this.retryNotice =
                         `Planning — network hiccup, retrying in ${formatDelay(notice.delayMs)} ` +
@@ -791,15 +819,26 @@ export class ChatScreen extends Screen {
      */
     async runTurn(token, turnMessages, approvalContext) {
         const runtime = new TaskRuntime({
+            executionMode: this.activeAgentMode,
             request: approvalContext.prompt, priorUserRequests: approvalContext.priorUserRequests,
             cwd: this.liveDir, signal: this.turnAbort?.signal, limits: taskLimits(loadConfig("standard")),
+            budgetScope: taskBudgetScope(loadConfig("standard")),
             journalDir: path.join(sessionDir("standard"), "tasks", path.basename(this.sessionId || "unsaved")),
         });
         this.taskRuntime = runtime;
         this.taskOutcome = "completed";
         let failed = false;
         try {
-            await runtime.run(() => this.runTaskTurn(token, turnMessages, approvalContext));
+            await runPluginTurn(runtime, { profile: "standard", cwd: this.liveDir, sessionId: this.sessionId ?? undefined, role: "main", request: approvalContext.prompt }, (name, args, signal) => this.requestApproval(name, args, approvalContext, signal), async () => {
+                const command = pluginCommand(approvalContext.prompt);
+                if (command) {
+                    const result = await runtime.plugins.runCommand(command.name, command.args);
+                    this.messages.push({ role: "assistant", content: typeof result === "string" ? result : JSON.stringify(result ?? null, null, 2) });
+                    this.onTurnFinished();
+                    return;
+                }
+                await this.runTaskTurn(token, turnMessages, approvalContext);
+            });
         }
         catch (error) {
             failed = true;
@@ -833,6 +872,8 @@ export class ChatScreen extends Screen {
         await this.autoCompress(token);
         if (token !== this.turnToken)
             return;
+        if (this.activeAgentMode === FAST_MODE)
+            return this.runFastTurn(token, turnMessages, approvalContext);
         if (this.activeAgentMode !== "standard")
             this.plan = null;
         const plan = this.activeAgentMode === "standard" ? await this.makePlan(token) : null;
@@ -905,6 +946,7 @@ export class ChatScreen extends Screen {
         this.publishLive();
         if (this.busy && !this.paused) {
             this.queued = trimmed;
+            this.queuedAgentMode = this.agentMode;
             this.app.render();
             return;
         }
@@ -937,7 +979,8 @@ export class ChatScreen extends Screen {
         this.busy = true;
         this.paused = false;
         this.app.state.isThinking = true;
-        this.activeAgentMode = this.agentMode;
+        this.activeAgentMode = this.queuedAgentMode ?? this.agentMode;
+        this.queuedAgentMode = null;
         this.turnAbort?.abort();
         this.turnAbort = new AbortController();
         const token = ++this.turnToken;
@@ -981,6 +1024,67 @@ export class ChatScreen extends Screen {
             }
         }
     }
+    async runFastTurn(token, turnMessages, approvalContext) {
+        assertFastAvailable(loadConfig());
+        const runtime = currentTask().runtime, signal = currentTask().signal;
+        this.plan = null;
+        const model = { ...this.model }, provider = this.modelProvider, intensity = this.intensity;
+        const stopped = () => token !== this.turnToken || this.paused;
+        const history = this.buildApiMessages(this.turnView(turnMessages));
+        if (this.fastState && ["failed", "cancelled", "cancelling"].includes(this.fastState.phase)) {
+            history.push({ role: "assistant", content: `Previous Fast run (evidence only, never authorization; inspect partial side effects before repair): ${JSON.stringify(this.fastState)}` });
+        }
+        const engine = new FastAgentEngine({
+            runtime, signal, cwd: this.liveDir, settings: fastSettings(loadConfig()),
+            directory: path.join(sessionDir(), "tasks", path.basename(this.sessionId || "unsaved"), "fast"),
+            history,
+            system: loadAgentPrompt(FAST_MODE), subagentSystem: loadSubAgentPrompt(),
+            contextWindow: modelContextWindow(provider, model), maxRounds: subAgentRounds(loadConfig().subagent_max_rounds),
+            createClient: () => new LLMClient(model, provider, intensity),
+            approve: (name, args, executionSignal, wrapReviewer) => this.requestApproval(name, args, {
+                ...approvalContext, context: captureApprovalContext(this.turnView(turnMessages)).context,
+            }, executionSignal, wrapReviewer ? () => {
+                const reviewer = this.reviewerModel();
+                return wrapReviewer(new LLMClient(reviewer.model, reviewer.provider, reviewer.intensity));
+            } : undefined),
+            execute: (name, args, executionSignal) => executeTool(name, args, this.liveDir, executionSignal),
+            onUsage: usage => {
+                if (token === this.turnToken || this.fastState?.run_id === engine.runId) {
+                    this.tokens.prompt += usage.prompt;
+                    this.tokens.completion += usage.completion;
+                }
+            },
+            onText: text => { if (!stopped()) {
+                this.streamingContent = text;
+                this.checkpoint.schedule();
+                this.publishLive();
+                this.app.render();
+            } },
+            onSnapshot: snapshot => {
+                if (!stopped() || (this.fastState?.run_id === snapshot.run_id && this.fastState.phase === "cancelling")) {
+                    this.fastState = snapshot;
+                    this.checkpoint.schedule();
+                    this.publishLive();
+                    this.app.render();
+                }
+            },
+            onTool: (name, args, result) => {
+                if (!stopped()) {
+                    this.messages.push({ role: "tool", name, arguments: args, result });
+                    this.save();
+                    this.publishLive();
+                }
+            },
+        });
+        const result = await engine.run();
+        if (stopped())
+            return;
+        this.fastState = result.snapshot;
+        this.taskOutcome = result.status;
+        this.messages.push({ role: "assistant", content: result.report });
+        this.streamingContent = null;
+        this.onTurnFinished();
+    }
     buildApiMessages(messages = this.messages, directive = "") {
         // A step directive extends the system prompt rather than adding a user
         // message: the plan is an instruction, not something the user just said.
@@ -1009,7 +1113,7 @@ export class ChatScreen extends Screen {
      */
     async agentLoop(apiMessages, token, approvalContext) {
         const tools = this.activeAgentMode === "ptc"
-            ? [...TOOLS, (await import("../llm/codemode.js")).getCodeToolDefinition()] : TOOLS;
+            ? [...getToolDefinitions(), (await import("../llm/codemode.js")).getCodeToolDefinition()] : getToolDefinitions();
         let emptyReplies = 0;
         try {
             while (true) {
@@ -1082,7 +1186,7 @@ export class ChatScreen extends Screen {
                     return false;
                 }
                 if (client.outcome?.error?.code.endsWith("_budget") && currentTask()) {
-                    const report = await finalTaskReport(currentTask().runtime, () => new LLMClient(this.model, this.modelProvider, this.intensity), usage => { this.tokens.prompt += usage.prompt; this.tokens.completion += usage.completion; });
+                    const report = await finalTaskReport(currentTask().runtime, () => new LLMClient(this.model, this.modelProvider, this.intensity), usage => { this.tokens.prompt += usage.prompt; this.tokens.completion += usage.completion; }, apiMessages);
                     if (token !== this.turnToken || this.paused)
                         return false;
                     this.taskOutcome = "partial";
@@ -1167,7 +1271,15 @@ export class ChatScreen extends Screen {
                         this.app.render();
                         continue;
                     }
-                    const result = await this.runTool(tc.name, args, toolMsg, token, apiMessages, approvalContext);
+                    let result;
+                    try {
+                        result = await this.runTool(tc.name, args, toolMsg, token, apiMessages, approvalContext);
+                    }
+                    catch (error) {
+                        toolMsg.result = `[Not executed: ${describeError(error)}]`;
+                        this.save();
+                        throw error;
+                    }
                     // A clear starts a different transcript while an old tool may finish.
                     if (!this.messages.includes(toolMsg))
                         return false;
@@ -1185,6 +1297,15 @@ export class ChatScreen extends Screen {
         catch (e) {
             if (token !== this.turnToken)
                 return false;
+            if (e instanceof TaskControlError && e.code.endsWith("_budget") && currentTask()) {
+                const report = await finalTaskReport(currentTask().runtime, () => new LLMClient(this.model, this.modelProvider, this.intensity), usage => { this.tokens.prompt += usage.prompt; this.tokens.completion += usage.completion; }, apiMessages);
+                if (token !== this.turnToken || this.paused)
+                    return false;
+                this.taskOutcome = "partial";
+                this.streamingContent = null;
+                this.messages.push({ role: "assistant", content: report });
+                return false;
+            }
             this.taskOutcome = "failed";
             const err = describeError(e);
             this.messages.push({ role: "assistant", content: (this.streamingContent ?? "") + `\n[Error: ${err}]` });
@@ -1217,11 +1338,15 @@ export class ChatScreen extends Screen {
     }
     // ---- approval gate ---------------------------------------------------
     /** Classify a tool call and, when it is risky, run it past the gate. */
-    async requestApproval(tool, args, context = captureApprovalContext(this.messages), signal = currentTask()?.runtime.signal ?? this.turnAbort?.signal) {
+    async requestApproval(tool, args, context = captureApprovalContext(this.messages), signal = currentTask()?.runtime.signal ?? this.turnAbort?.signal, createReviewerClient) {
+        context = pluginApprovalContext(context);
         const linked = linkSignals(signal, currentTask()?.signal);
         signal = linked.signal;
         try {
             currentTask()?.runtime.assertTool(tool, args);
+            const plugins = currentTask()?.runtime.plugins;
+            if (plugins)
+                await plugins.guardTool(tool, args);
         }
         catch (error) {
             linked.dispose();
@@ -1236,8 +1361,9 @@ export class ChatScreen extends Screen {
         const cancelled = () => approvalToken !== this.turnToken || this.paused || signal?.aborted === true;
         const gate = new ApprovalGate({
             cancelled,
-            askHuman: () => cancelled() ? Promise.resolve(false) : this.askHuman(tool, args, risk),
+            askHuman: () => this.askHuman(tool, args, risk, cancelled, signal),
             reviewer: () => this.reviewerModel(),
+            ...(createReviewerClient ? { createReviewerClient } : {}),
             autoApprovalEnabled: () => this.approvalMode === "auto",
             extremeAutoApprovalEnabled: () => loadConfig().auto_approve_extreme_risk === true,
             // Reviews happen before any card is shown, so without this the app looks
@@ -1275,9 +1401,18 @@ export class ChatScreen extends Screen {
         }
     }
     /** 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 };
+    askHuman(tool, args, risk, cancelled, signal) {
+        const requestedMode = this.approvalMode;
+        return this.approvalQueue.run(() => new Promise((resolve) => {
+            if (cancelled()) {
+                resolve(false);
+                return;
+            }
+            if (requestedMode !== this.approvalMode) {
+                resolve(null);
+                return;
+            }
+            this.pendingApproval = { id: randomUUID(), tool, args, risk, resolve };
             this.app.state.approval = { tool, level: risk.level };
             // The card floats over the same corner the approval card needs on a short
             // terminal, and a decision the user cannot see is not a decision. The plan
@@ -1286,7 +1421,7 @@ export class ChatScreen extends Screen {
             this.app.bell?.("approval");
             this.app.render();
             this.publishLive();
-        });
+        }), signal);
     }
     /** Answer the pending request (keyboard, mouse, or the web UI). */
     settleApproval(approved) {
@@ -1480,7 +1615,7 @@ export class ChatScreen extends Screen {
             createClient: () => new LLMClient(this.model, this.modelProvider, this.intensity),
             system: loadSubAgentPrompt(),
             task: buildSubAgentTask({ task, context, cwd: this.liveDir, rounds: maxRounds }),
-            tools: SUB_AGENT_TOOLS,
+            tools: getSubAgentToolDefinitions(),
             maxRounds,
             approve: (name, callArgs) => this.requestApproval(name, callArgs, approval, signal),
             execute: (name, callArgs) => name === DELEGATE_TOOL
@@ -1544,7 +1679,7 @@ export class ChatScreen extends Screen {
     /**
      * A finished turn is only worth folding when the work it hides is substantial.
      * Whether it is folded right now is a separate question (`expandedTurns`), and
-     * its reply is never part of what it hides.
+     * its user input and reply are never part of what it hides.
      */
     turnHides(start, end) {
         if (!this.finishedTurns.has(start))
@@ -1553,12 +1688,12 @@ export class ChatScreen extends Screen {
         let blocks = 0;
         let chars = 0;
         for (let i = start; i < end; i++) {
-            // The reply stays on screen, so it is neither hidden content nor a reason
-            // to fold: a long answer alone must never collapse its own turn.
+            // User input and the reply stay on screen, so neither counts toward the
+            // folding threshold, however long either one is.
             if (i === answer)
                 continue;
             const m = this.messages[i];
-            if (m.role === "user" || m.role === "assistant") {
+            if (m.role === "assistant") {
                 blocks++;
                 chars += m.content.length;
             }
@@ -1613,23 +1748,6 @@ export class ChatScreen extends Screen {
         }
         return map;
     }
-    /**
-     * The first line of the first message in `role`. Only one line: the header is
-     * a signpost, and the full text is one click away.
-     */
-    turnPreview(start, end, role) {
-        for (const m of this.messages.slice(start, end)) {
-            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;
@@ -1646,13 +1764,10 @@ export class ChatScreen extends Screen {
             }, -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);
-        // The prompt and the reply sit either side of the work this fold hides, so
-        // the control line goes between them and the answer stays on screen below.
-        const hidden = this.turnAnswer(start, end) < 0 ? count : count - 1;
+        const answer = this.turnAnswer(start, end);
+        const hidden = this.messages.slice(start, end).filter((message, offset) => message.role !== "user" && message.role !== "system" && start + offset !== answer).length;
         const meta = `${hidden} of ${count} message${count === 1 ? "" : "s"} folded`;
-        add({ spans: [{ text: ellipsize(`  ${meta} — click to expand`, width), style: { fg: C.dim } }] }, -1, start);
+        add({ spans: [{ text: ellipsize(`▸ ${meta} — click to expand`, width), style: { fg: C.dim } }] }, -1, start);
     }
     /** Fold or unfold one turn. */
     toggleTurn(start) {
@@ -1793,7 +1908,7 @@ export class ChatScreen extends Screen {
         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.plan, "standard", undefined, this.agentMode, this.taskRuntime?.snapshot() ?? this.lastTask);
+            this.sessionId = saveSession(chatMessages, this.model.name, this.modelProvider, this.intensity, this.liveDir, this.sessionId ?? undefined, this.tokens, this.context, this.approvalMode, this.plan, "standard", undefined, this.agentMode, this.taskRuntime?.snapshot() ?? this.lastTask, this.fastState);
             this.saveError = null;
             return true;
         }
@@ -1845,30 +1960,28 @@ export class ChatScreen extends Screen {
                 archived = context !== null && recordIndex < context.end;
                 recordIndex++;
             }
-            // A foldable turn always shows its control lines first; its work then
-            // renders when the reader has opened it, and its reply always does.
-            if (m.role !== "system" && turn === mi && !(archived && !this.expandedContext)) {
-                this.pushTurnHeader(mi, this.turnEnd(mi), width, add);
-            }
             const folded = turn >= 0 && !this.expandedTurns.has(turn);
             const reply = folded && answers[mi] === mi;
             if (m.role === "system") {
                 pushText(sanitizeText(m.content), { fg: C.dim });
             }
-            else if ((archived && !this.expandedContext) || (folded && !reply)) {
-                // Hidden: by the collapsed "Earlier conversation" fold, or by the turn's
-                // own fold, which hides the prompt body and the work but never the
-                // reply. 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 });
+                pushMarkdown(sanitizeText(terminalTemplate("chat.message.renderer", { content: m.content, role: "user" }) ?? m.content), { fg: C.user });
                 add({ spans: [] });
+                // The fold control follows the complete prompt, which stays visible
+                // even when the turn or the earlier conversation is collapsed.
+                if (turn === mi && !(archived && !this.expandedContext)) {
+                    this.pushTurnHeader(mi, this.turnEnd(mi), width, add);
+                }
+            }
+            else if ((archived && !this.expandedContext) || (folded && !reply)) {
+                // Only AI output is hidden. Every message remains in the transcript,
+                // on disk and in the request; the controls reveal it again.
             }
             else if (m.role === "assistant") {
                 add({ spans: [{ text: "Neutrino:", style: { fg: C.accent, bold: true } }] });
-                pushMarkdown(sanitizeText(m.content), { fg: C.assistant });
+                pushMarkdown(sanitizeText(terminalTemplate("chat.message.renderer", { content: m.content, role: "assistant" }) ?? m.content), { fg: C.assistant });
                 add({ spans: [] });
             }
             else if (m.role === "summary") {
@@ -1906,7 +2019,7 @@ export class ChatScreen extends Screen {
                 }
                 // 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 || "");
+                const body = sanitizeText(terminalTemplate("chat.card.tool", { name: m.name, result: m.result, role: "tool", arguments: JSON.stringify(m.arguments) }) ?? 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);
@@ -1918,7 +2031,7 @@ export class ChatScreen extends Screen {
                 }
                 add({ spans: [] });
             }
-            if (context && archived && recordIndex === context.end) {
+            if (context && archived && recordIndex === context.end && this.expandedContext) {
                 this.contextLines.add(lines.length);
                 add({ spans: [{ text: "▾ Collapse earlier conversation", style: { fg: C.amber } }] });
                 add({ spans: [] });
@@ -2028,7 +2141,7 @@ export class ChatScreen extends Screen {
             active: true,
             dimmed: this.busy,
             cursorOn: this.app.state.cursorOn,
-            placeholder: "Type a message...",
+            placeholder: sanitizeText(terminalTemplate("chat.composer", { text: this.inputValue }) ?? "Type a message...", { singleLine: true }),
         });
         const hintY = h - 1;
         const hints = "Enter send · Ctrl+P plan · Ctrl+C pause · ESC ESC pause · Ctrl+A approval · Ctrl+B menu · Ctrl+L clear · drag to copy";
@@ -2090,7 +2203,8 @@ export class ChatScreen extends Screen {
                 { kind: "line", text: `Total: ${total}` },
             ];
         }
-        const rows = planCardRows(plan, { width, maxRows: Math.max(1, maxRows - 1) });
+        const custom = terminalTemplate("chat.card.plan", { plan: JSON.stringify(plan), role: "main" });
+        const rows = custom ? wrapText(sanitizeText(custom), width).slice(0, Math.max(1, maxRows - 1)).map(text => ({ kind: "line", text })) : planCardRows(plan, { width, maxRows: Math.max(1, maxRows - 1) });
         rows.push({ kind: "line", text: `Tokens ${this.tokens.prompt} → ${this.tokens.completion}` });
         return rows;
     }

package/dist/screens/history.d.ts

@@ -0,0 +1,23 @@
+import type { Buffer } from "../terminal/buffer.js";
+import { Screen } from "../terminal/screen.js";
+import type { Key, MouseEvent } from "../terminal/input.js";
+export declare class HistoryScreen extends Screen {
+    private sessions;
+    private selectedIdx;
+    private scrollTop;
+    private lastHoverX;
+    private lastHoverY;
+    private rows;
+    private itemBounds;
+    private cwd;
+    onActivate(): void;
+    private move;
+    onKey(key: Key): void;
+    onMouse(ev: MouseEvent): void;
+    /** Map a terminal row to the history item index (0 = "Open other Agent's history"). */
+    private itemIndexAtRow;
+    private loadSelected;
+    private deleteSelected;
+    private buildRows;
+    render(buf: Buffer): void;
+}

package/dist/screens/modelSelect.d.ts

@@ -0,0 +1,29 @@
+import type { Buffer } from "../terminal/buffer.js";
+import { Screen } from "../terminal/screen.js";
+import type { Key, MouseEvent } from "../terminal/input.js";
+export declare class ModelSelectScreen extends Screen {
+    private level;
+    private providers;
+    private modelMap;
+    private selectedProviderIdx;
+    private selectedModelIdx;
+    private selectedIntensityIdx;
+    private scrollBtn;
+    private lastHoverX;
+    private lastHoverY;
+    onActivate(): void;
+    private currentList;
+    /** Only the intensity names this exact model accepts. */
+    private currentIntensities;
+    private currentIdx;
+    private setIdx;
+    private move;
+    private confirm;
+    private goBack;
+    /** Map a terminal row to the list index rendered there, if any. */
+    private indexAtRow;
+    onMouse(ev: MouseEvent): void;
+    onKey(key: Key): void;
+    render(buf: Buffer): void;
+    private currentModelName;
+}

package/dist/screens/plugins.d.ts

@@ -0,0 +1,29 @@
+import { Screen } from "../terminal/screen.js";
+import type { Buffer } from "../terminal/buffer.js";
+import type { Key, MouseEvent } from "../terminal/input.js";
+import type { OwnedUI } from "../plugins/host.js";
+export declare class PluginViewScreen extends Screen {
+    private item;
+    private offset;
+    constructor(item: OwnedUI);
+    onKey(key: Key): void;
+    onMouse(ev: MouseEvent): void;
+    render(buf: Buffer): void;
+}
+export declare class PluginsScreen extends Screen {
+    private profile;
+    private plugins;
+    private index;
+    private detail;
+    private editing;
+    private draft;
+    private message;
+    private trustPending;
+    onActivate(): void;
+    private refresh;
+    private action;
+    onKey(key: Key): void;
+    onPaste(text: string): void;
+    onMouse(ev: MouseEvent): void;
+    render(buf: Buffer): void;
+}