@xingjisoft/neutrino 0.6.2 → 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";
@@ -21,9 +27,7 @@ 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 thinking and the tool calls —
  * while the full user prompt and final reply always stay on screen. Doing
@@ -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,6 +819,7 @@ 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")),
@@ -800,7 +829,16 @@ export class ChatScreen extends Screen {
         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;
@@ -834,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;
@@ -906,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;
         }
@@ -938,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;
@@ -982,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.
@@ -1010,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) {
@@ -1235,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();
@@ -1254,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
@@ -1293,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
@@ -1304,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) {
@@ -1498,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
@@ -1791,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;
         }
@@ -1850,7 +1967,7 @@ export class ChatScreen extends 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.
@@ -1864,7 +1981,7 @@ export class ChatScreen extends Screen {
             }
             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") {
@@ -1902,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);
@@ -2024,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";
@@ -2086,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;
+}

package/dist/screens/plugins.js

@@ -0,0 +1,196 @@
+import { Screen } from "../terminal/screen.js";
+import { C } from "../colors.js";
+import { drawHeader } from "../header.js";
+import { drawHint } from "../ui.js";
+import { configurePlugin, installPlugin, listPlugins, removePlugin, rollbackPlugin, selectProvider } from "../plugins/manager.js";
+import { invalidateTuiPlugins, terminalUI } from "../plugins/terminal.js";
+import { sanitizeText } from "../sanitize.js";
+export class PluginViewScreen extends Screen {
+    item;
+    offset = 0;
+    constructor(item) {
+        super();
+        this.item = item;
+    }
+    onKey(key) { if (key.name === "escape" || key.name === "backspace") {
+        this.app.popScreen();
+        return;
+    } if (key.name === "down" || key.name === "pagedown")
+        this.offset++; if (key.name === "up" || key.name === "pageup")
+        this.offset = Math.max(0, this.offset - 1); this.app.render(); }
+    onMouse(ev) { if (ev.type === "click" && ev.button === 2)
+        this.app.popScreen(); }
+    render(buf) { drawHeader(buf, this.app.state); buf.writeText(2, 3, this.item.title, { fg: C.accent, bold: true }); const text = sanitizeText(this.item.text ?? "This view is available in the browser. / 此视图可在浏览器中打开。"); text.split("\n").slice(this.offset, this.offset + Math.max(1, buf.height - 8)).forEach((line, i) => buf.writeText(2, 5 + i, line.slice(0, Math.max(1, buf.width - 4)), { fg: C.white })); drawHint(buf, buf.height - 2, "Esc back · ↑/↓ scroll"); }
+}
+export class PluginsScreen extends Screen {
+    profile = "standard";
+    plugins = [];
+    index = 0;
+    detail = false;
+    editing = null;
+    draft = "";
+    message = "";
+    trustPending = false;
+    onActivate() { this.refresh(); }
+    refresh() { try {
+        this.plugins = listPlugins(this.profile).plugins;
+        this.index = Math.min(this.index, Math.max(0, this.plugins.length - 1));
+        invalidateTuiPlugins();
+    }
+    catch (e) {
+        this.message = e.message;
+    } }
+    action(run) { try {
+        run();
+        this.message = "Saved / 已保存";
+        this.refresh();
+    }
+    catch (e) {
+        this.message = e.message;
+    } this.app.render(); }
+    onKey(key) {
+        if (this.editing) {
+            if (key.name === "escape") {
+                this.editing = null;
+                this.app.render();
+                return;
+            }
+            if (key.name === "return") {
+                const type = this.editing;
+                this.editing = null;
+                this.action(() => { if (type === "install")
+                    installPlugin(this.draft);
+                else
+                    configurePlugin(this.plugins[this.index].manifest.id, { config: JSON.parse(this.draft) }, this.profile); });
+                return;
+            }
+            if (key.name === "backspace")
+                this.draft = this.draft.slice(0, -1);
+            else if (!key.ctrl && !key.meta && key.name.length === 1)
+                this.draft += key.name;
+            this.app.render();
+            return;
+        }
+        if (key.name === "escape" || key.name === "backspace") {
+            if (this.detail) {
+                this.detail = false;
+                this.trustPending = false;
+                this.app.render();
+            }
+            else
+                this.app.popScreen();
+            return;
+        }
+        if (key.name === "tab") {
+            this.profile = this.profile === "standard" ? "pro" : "standard";
+            this.refresh();
+            this.app.render();
+            return;
+        }
+        if (key.name === "up") {
+            this.index = Math.max(0, this.index - 1);
+            this.app.render();
+            return;
+        }
+        if (key.name === "down") {
+            this.index = Math.min(this.plugins.length - 1, this.index + 1);
+            this.app.render();
+            return;
+        }
+        if (key.name === "i") {
+            this.editing = "install";
+            this.draft = "";
+            this.app.render();
+            return;
+        }
+        if (key.name === "m") {
+            const items = terminalUI().filter(u => ["app.menu", "workspace.tabs", "settings.sections"].includes(u.slot));
+            if (items.length)
+                this.app.pushScreen(new PluginViewScreen({ ...items[0], text: items.map(i => `${i.title}\n${i.text ?? ""}`).join("\n\n") }));
+            return;
+        }
+        const p = this.plugins[this.index];
+        if (!p)
+            return;
+        if (key.name === "return") {
+            this.detail = !this.detail;
+            this.app.render();
+            return;
+        }
+        if (key.name === "e") {
+            if (!p.enabled && p.manifest.runtime === "native" && p.manifest.entries?.agent) {
+                this.trustPending = true;
+                this.message = "Native plugin can execute unrestricted local code. Press Y to trust this exact revision, Esc to cancel.";
+                this.app.render();
+                return;
+            }
+            this.action(() => configurePlugin(p.manifest.id, { enabled: !p.enabled }, this.profile));
+            return;
+        }
+        if (key.name === "y" && this.trustPending) {
+            this.trustPending = false;
+            this.action(() => configurePlugin(p.manifest.id, { enabled: true, trustNative: true }, this.profile));
+            return;
+        }
+        if (key.name === "c") {
+            this.editing = "config";
+            this.draft = JSON.stringify(p.config);
+            this.app.render();
+            return;
+        }
+        if (key.name === "u") {
+            this.action(() => { installPlugin(p.source); });
+            return;
+        }
+        if (key.name === "r") {
+            this.action(() => rollbackPlugin(p.manifest.id));
+            return;
+        }
+        if (key.name === "d") {
+            this.action(() => removePlugin(p.manifest.id));
+            return;
+        }
+        if (key.name === "v") {
+            const replacements = (p.manifest.contributes?.ui ?? []).filter(u => ["chat.composer", "chat.message.renderer", "chat.card.plan", "chat.card.tool"].includes(u.slot));
+            this.action(() => { for (const u of replacements)
+                selectProvider(u.slot, `${p.manifest.id}/${u.id}`, this.profile); for (const prompt of p.manifest.contributes?.prompts ?? [])
+                if (prompt.replace)
+                    selectProvider("persona", `${p.manifest.id}/${prompt.id}`, this.profile); });
+        }
+    }
+    onPaste(text) { if (this.editing) {
+        this.draft += text;
+        this.app.render();
+    } }
+    onMouse(ev) { if (ev.type === "click" && ev.button === 2)
+        this.app.popScreen();
+    else if (ev.type === "click" && ev.button === 0 && ev.y >= 5) {
+        this.index = Math.min(this.plugins.length - 1, Math.max(0, ev.y - 5));
+        this.app.render();
+    } }
+    render(buf) {
+        drawHeader(buf, this.app.state);
+        buf.writeText(2, 2, `Plugins / 插件 · ${this.profile}`, { fg: C.accent, bold: true });
+        let y = 4;
+        if (this.editing) {
+            buf.writeText(2, y++, this.editing === "install" ? "Local plugin directory / 本机插件目录" : "Configuration JSON / 配置 JSON", { fg: C.white });
+            buf.writeText(2, y++, this.draft.slice(-Math.max(1, buf.width - 5)), { fg: C.accent });
+        }
+        else if (this.detail && this.plugins[this.index]) {
+            const p = this.plugins[this.index];
+            const lines = [p.manifest.name, `${p.manifest.id} @ ${p.manifest.version}`, p.manifest.description ?? "", `Runtime: ${p.manifest.runtime ?? "sandbox"}`, `Permissions: ${(p.manifest.permissions ?? []).join(", ")}`, `Source: ${p.source}`, `Integrity: ${p.integrity}`, p.error ?? "", JSON.stringify(p.config)];
+            for (const line of lines)
+                buf.writeText(2, y++, sanitizeText(line, { singleLine: true }).slice(0, buf.width - 4), { fg: C.white });
+        }
+        else {
+            if (!this.plugins.length)
+                buf.writeText(2, 5, "No plugins. Press I to install a local directory. / 按 I 安装本机插件。", { fg: C.dim });
+            const start = Math.max(0, this.index - Math.max(1, buf.height - 12) + 1);
+            this.plugins.slice(start, start + Math.max(1, buf.height - 12)).forEach((p, i) => buf.writeText(2, 5 + i, `${i + start === this.index ? "›" : " "} ${p.enabled ? "●" : "○"} ${p.manifest.name}  ${p.manifest.version}${p.error ? " !" : ""}`.slice(0, buf.width - 4), { fg: i + start === this.index ? C.accent : C.white, bold: i + start === this.index }));
+        }
+        if (this.message)
+            buf.writeText(2, buf.height - 4, sanitizeText(this.message, { singleLine: true }).slice(0, buf.width - 4), { fg: C.amber });
+        drawHint(buf, buf.height - 3, "↑/↓ select · Enter details · E enable/disable · I install · C config · U update");
+        drawHint(buf, buf.height - 2, "R rollback · D remove · V select providers · M extensions · Tab profile · Esc back");
+    }
+}