@xingjisoft/neutrino 0.3.0 → 0.4.1

package/dist/pro/preflight.js

@@ -0,0 +1,172 @@
+import { loadModels } from "../config.js";
+import { ACTIVE_PRO_ROLES, loadProModels, } from "./config.js";
+export class ProPreflightError extends Error {
+    fallbacks;
+    constructor(message, fallbacks) {
+        super(message);
+        this.fallbacks = fallbacks;
+        this.name = "ProPreflightError";
+    }
+}
+function reference(preset, setting) {
+    return { provider: setting?.provider ?? "", model: setting?.model ?? "", tier: preset.name };
+}
+function resolveSetting(role, preset, catalog) {
+    const setting = preset["model-setting"].find((entry) => entry.type === role);
+    if (!setting?.provider.trim() || !setting.model?.trim() || setting.model.trim().toLowerCase() === "null") {
+        return { reason: "role has no model configured" };
+    }
+    const provider = catalog.providers.find((entry) => entry.name === setting.provider);
+    const model = provider?.models.find((entry) => entry.name === setting.model);
+    if (!model)
+        return { reason: "provider/model is missing from the shared catalogue" };
+    if (!model.api_key?.trim())
+        return { reason: "API key is missing in the shared catalogue" };
+    let endpoint;
+    try {
+        endpoint = new URL(model.url);
+    }
+    catch {
+        return { reason: "model endpoint is invalid" };
+    }
+    if (!["http:", "https:"].includes(endpoint.protocol))
+        return { reason: "model endpoint must use HTTP or HTTPS" };
+    const intensity = setting.intensity.trim().toLowerCase() || "high";
+    if (!["low", "medium", "high", "xhigh", "max", "ultra"].includes(intensity)) {
+        return { reason: "thinking intensity is invalid" };
+    }
+    // The Pro file can use xhigh, which must not be normalized through the
+    // ordinary mode's five intensity labels. Explicit shared limits still apply.
+    if (model.intensity?.length && !model.intensity.some((level) => level.toLowerCase() === intensity)) {
+        return { reason: "thinking intensity is not supported by this model" };
+    }
+    return {
+        resolved: {
+            role, provider: provider.name, model: { ...model }, intensity,
+            context_window: setting.context_window, tier: preset.name,
+        },
+    };
+}
+/** An authenticated, tiny inference validates the same intensity/tool contract. */
+async function probe(model, options) {
+    const controller = new AbortController();
+    const relay = () => controller.abort(options.signal?.reason);
+    if (options.signal?.aborted)
+        relay();
+    else
+        options.signal?.addEventListener("abort", relay, { once: true });
+    const timer = setTimeout(() => controller.abort(), options.timeoutMs ?? 20_000);
+    const anthropic = model.provider === "Anthropic";
+    const parameters = { type: "object", properties: {}, additionalProperties: false };
+    const tool = {
+        name: "pro_availability_check", description: "A harmless availability check; this tool is never executed.",
+    };
+    const payload = anthropic ? {
+        model: model.model.name, stream: false, max_tokens: 4096,
+        output_config: { effort: model.intensity },
+        messages: [{ role: "user", content: "Availability check. Reply only OK. Do not call tools." }],
+        tools: [{ ...tool, input_schema: parameters }],
+    } : {
+        model: model.model.name, stream: false, reasoning_effort: model.intensity,
+        messages: [{ role: "user", content: "Availability check. Reply only OK. Do not call tools." }],
+        tools: [{ type: "function", function: { ...tool, parameters } }],
+    };
+    try {
+        const response = await fetch(model.model.url.replace(/\/+$/, "") + (anthropic ? "/messages" : "/chat/completions"), {
+            method: "POST", signal: controller.signal,
+            headers: {
+                "Content-Type": "application/json",
+                ...(anthropic
+                    ? { "x-api-key": model.model.api_key, "anthropic-version": "2023-06-01" }
+                    : { Authorization: `Bearer ${model.model.api_key}` }),
+            },
+            body: JSON.stringify(payload),
+        });
+        if (!response.ok) {
+            // Never echo endpoint responses: they can repeat credentials or URLs.
+            await response.body?.cancel();
+            return { ok: false, reason: `availability request returned HTTP ${response.status}` };
+        }
+        const body = await response.json();
+        if (body.error || (anthropic ? !Array.isArray(body.content) : !body.choices?.[0]?.message)) {
+            return { ok: false, reason: "endpoint did not return a valid model completion" };
+        }
+        if (body.usage) {
+            const prompt = body.usage.prompt_tokens ?? body.usage.input_tokens ?? 0;
+            const completion = body.usage.completion_tokens ?? body.usage.output_tokens ?? 0;
+            options.onUsage?.({ prompt, completion, total: prompt + completion });
+        }
+        return { ok: true, reason: "" };
+    }
+    catch {
+        if (options.signal?.aborted)
+            throw new Error("Pro availability check was cancelled");
+        return { ok: false, reason: controller.signal.aborted ? "availability request timed out" : "availability request failed" };
+    }
+    finally {
+        clearTimeout(timer);
+        options.signal?.removeEventListener("abort", relay);
+    }
+}
+/**
+ * Resolve each job independently, descending only within that job. Neither the
+ * shared catalogue nor the Pro presets are edited by a temporary replacement.
+ */
+export async function resolveProTeam(presetName, options = {}) {
+    const presets = loadProModels().tier;
+    const selected = presets.find((preset) => preset.name === presetName);
+    if (!selected)
+        throw new Error("Unknown Pro preset");
+    const catalog = loadModels();
+    const ranked = presets.filter((preset) => preset.name !== "custom" && preset.name !== "auto");
+    const selectedIndex = ranked.findIndex((preset) => preset.name === selected.name);
+    // Custom/auto entries define their own team rather than a quality rank.
+    const candidates = selectedIndex < 0 ? [selected] : ranked.slice(0, selectedIndex + 1).reverse();
+    const cache = new Map();
+    const outcomes = await Promise.all(ACTIVE_PRO_ROLES.map(async (role) => {
+        const failures = [];
+        const requested = reference(selected, selected["model-setting"].find((entry) => entry.type === role));
+        for (const preset of candidates) {
+            if (options.signal?.aborted)
+                throw new Error("Pro availability check was cancelled");
+            const lookup = resolveSetting(role, preset, catalog);
+            if ("reason" in lookup) {
+                failures.push(`${preset.name}: ${lookup.reason}`);
+                continue;
+            }
+            const resolved = lookup.resolved;
+            const key = JSON.stringify([resolved.provider, resolved.model.name, resolved.intensity]);
+            let pending = cache.get(key);
+            if (!pending) {
+                pending = probe(resolved, options);
+                cache.set(key, pending);
+            }
+            const result = await pending;
+            if (!result.ok) {
+                failures.push(`${preset.name}: ${result.reason}`);
+                continue;
+            }
+            return {
+                role, resolved,
+                fallback: failures.length ? {
+                    role, requested, replacement: { provider: resolved.provider, model: resolved.model.name, tier: resolved.tier },
+                    reason: failures.join("; "),
+                } : null,
+            };
+        }
+        return { role, resolved: null, fallback: { role, requested, replacement: null, reason: failures.join("; ") } };
+    }));
+    const models = {};
+    const fallbacks = [];
+    for (const outcome of outcomes) {
+        if (outcome.resolved)
+            models[outcome.role] = outcome.resolved;
+        if (outcome.fallback)
+            fallbacks.push(outcome.fallback);
+    }
+    const unavailable = outcomes.filter((outcome) => !outcome.resolved).map((outcome) => outcome.role);
+    if (unavailable.length) {
+        throw new ProPreflightError(`No available Pro model for: ${unavailable.join(", ")}`, fallbacks);
+    }
+    return { models, fallbacks };
+}

package/dist/screens/agentConversation.js

@@ -1,17 +1,22 @@
 import { Screen } from "../terminal/screen.js";
 import { C } from "../colors.js";
 import { drawHeader } from "../header.js";
-import { drawHint, drawScrollbar } from "../ui.js";
+import { drawHint, drawScrollbar, inRect } from "../ui.js";
 import { drawSpans, renderMarkdownText } from "../markdown.js";
-import { ellipsize } from "../width.js";
+import { displayWidth, ellipsize, truncateByWidth } from "../width.js";
+import { migrateAgentSession } from "../migration.js";
 export class AgentConversationScreen extends Screen {
+    source;
     title;
     messages;
     scrollTop = 0;
     followBottom = true;
     scrollbarGeom = null;
-    constructor(title, messages) {
+    migrateButton = null;
+    migrationError = "";
+    constructor(title, messages, source) {
         super();
+        this.source = source;
         this.title = title;
         this.messages = messages;
     }
@@ -37,6 +42,10 @@ export class AgentConversationScreen extends Screen {
         else if (key.name === "escape") {
             this.app.popScreen();
         }
+        else if (key.name === "enter" || key.name === "return" ||
+            (!key.ctrl && !key.meta && key.char.toLowerCase() === "m")) {
+            this.migrate();
+        }
     }
     onMouse(ev) {
         if (ev.type === "wheel") {
@@ -52,6 +61,28 @@ export class AgentConversationScreen extends Screen {
         else if (ev.type === "click" && ev.button === 2) {
             this.app.popScreen();
         }
+        else if (ev.type === "click" && ev.button === 0 && this.migrateButton &&
+            inRect(ev.x, ev.y, this.migrateButton)) {
+            this.migrate();
+        }
+    }
+    migrate() {
+        if (!this.messages.length)
+            return;
+        try {
+            const state = this.app.state;
+            const session = migrateAgentSession(this.source.agent, this.source.id, this.source.cwd, {
+                provider: state.selectedProvider, model: state.selectedModelName, intensity: state.selectedIntensity,
+            });
+            this.app.loadSession(session);
+        }
+        catch (error) {
+            this.migrationError = error instanceof Error ? error.message : String(error);
+            this.app.render();
+        }
+    }
+    alwaysRepaintRows() {
+        return [this.app.height - 3, this.app.height - 2, this.app.height - 1];
     }
     scrollbar() {
         const g = this.scrollbarGeom;
@@ -93,7 +124,7 @@ export class AgentConversationScreen extends Screen {
         const h = buf.height;
         buf.centerText(1, ellipsize(this.title, Math.max(10, w - 4)), { fg: C.dim });
         const logTop = 3;
-        const logBottom = h - 2;
+        const logBottom = h - 4;
         const viewH = Math.max(1, logBottom - logTop + 1);
         const lines = this.buildLines(Math.max(10, w - 4));
         const maxScroll = Math.max(0, lines.length - viewH);
@@ -118,6 +149,18 @@ export class AgentConversationScreen extends Screen {
         }
         // Scrollbar on the right edge, visible only when the log overflows.
         drawScrollbar(buf, w - 1, logTop, logBottom, lines.length, viewH, this.scrollTop);
-        drawHint(buf, h - 1, "↑/↓ scroll  ·  wheel or drag the bar  ·  right-click back  ·  Esc back");
+        if (this.migrationError) {
+            buf.writeText(2, h - 3, ellipsize(`迁移失败：${this.migrationError}`, Math.max(0, w - 4)), { fg: C.red });
+        }
+        const label = truncateByWidth("[ 迁移会话 ]", Math.max(0, w - 2));
+        const buttonWidth = displayWidth(label);
+        this.migrateButton = { x: Math.max(0, w - buttonWidth - 2), y: h - 2, w: buttonWidth, h: 1 };
+        buf.writeText(this.migrateButton.x, this.migrateButton.y, label, {
+            fg: this.messages.length ? C.accent : C.dim, bg: C.highlightBg, bold: true,
+        });
+        for (let x = this.migrateButton.x; x < this.migrateButton.x + buttonWidth; x++) {
+            buf.markChrome(x, this.migrateButton.y);
+        }
+        drawHint(buf, h - 1, "↑/↓ scroll  ·  M/Enter migrate  ·  right-click back  ·  Esc back");
     }
 }

package/dist/screens/agentHistory.js

@@ -97,8 +97,10 @@ export class AgentHistoryScreen extends Screen {
         if (this.selectedIdx < 0 || this.selectedIdx >= this.sessions.length)
             return;
         const s = this.sessions[this.selectedIdx];
-        const messages = loadAgentMessages(this.agent, s.id);
-        this.app.pushScreen(new AgentConversationScreen(`${this.label} · ${s.title || s.id}`, messages));
+        const messages = loadAgentMessages(this.agent, s.id, this.cwd);
+        this.app.pushScreen(new AgentConversationScreen(`${this.label} · ${s.title || s.id}`, messages, {
+            agent: this.agent, id: s.id, cwd: this.cwd,
+        }));
     }
     buildRows() {
         const rows = [];

package/dist/screens/chat.js

@@ -1,6 +1,6 @@
 import { Screen } from "../terminal/screen.js";
 import { C } from "../colors.js";
-import { findModel, contextCompressionThreshold, loadConfig, loadModels, loadPlannerPrompt, loadStepPrompt, loadSubAgentPrompt, normalizeApprovalMode, planFirstEnabled, loadPrompt, saveSession, } from "../config.js";
+import { findModel, findConfiguredModel, intensityForModel, contextCompressionThreshold, loadConfig, loadPlannerPrompt, loadStepPrompt, loadSubAgentPrompt, normalizeApprovalMode, planFirstEnabled, loadPrompt, saveSession, } from "../config.js";
 import { drawHeader } from "../header.js";
 import { computeInputWindow, cursorFromColumn, drawInputBox, drawScrollbar, wrapText, approvalToggle, drawApprovalToggle, inRect } from "../ui.js";
 import { drawSpans, renderMarkdownText } from "../markdown.js";
@@ -175,12 +175,18 @@ export class ChatScreen extends Screen {
         };
         // The selected-state snapshot has no room for provider options; re-read the
         // thinking-mode flag from model.json so a hand-configured endpoint keeps it.
-        const configured = loadModels().providers
-            .find((provider) => provider.name === this.modelProvider)?.models
-            .find((model) => model.name === this.model.name);
-        if (configured && typeof configured.reasoning === "boolean")
-            this.model.reasoning = configured.reasoning;
-        this.intensity = this.loadedIntensity ?? st.selectedIntensity;
+        const configured = findConfiguredModel(this.modelProvider, this.model.name);
+        if (configured) {
+            if (typeof configured.reasoning === "boolean")
+                this.model.reasoning = configured.reasoning;
+            this.model.intensity = configured.intensity;
+        }
+        const savedIntensity = this.loadedIntensity ?? st.selectedIntensity;
+        this.intensity = intensityForModel(configured, savedIntensity, loadConfig().default_intensity);
+        // A resumed transcript can carry a level its model no longer accepts; the
+        // header and the next request must show and use the level actually in use.
+        if (this.intensity !== savedIntensity)
+            this.app.state.selectedIntensity = this.intensity;
         if (this.loadedTokens) {
             this.tokens = { prompt: this.loadedTokens.prompt, completion: this.loadedTokens.completion };
         }
@@ -230,7 +236,7 @@ export class ChatScreen extends Screen {
         }
         this.modelProvider = selection.provider;
         this.model = { ...selection.model };
-        this.intensity = selection.intensity;
+        this.intensity = intensityForModel(this.model, selection.intensity, loadConfig().default_intensity);
         Object.assign(this.app.state, {
             selectedProvider: this.modelProvider, selectedModelName: this.model.name,
             selectedModelUrl: this.model.url, selectedModelApiKey: this.model.api_key,

package/dist/screens/modelSelect.js

@@ -1,6 +1,6 @@
 import { Screen } from "../terminal/screen.js";
 import { C } from "../colors.js";
-import { INTENSITY_LEVELS, getModelsByProvider } from "../config.js";
+import { intensityForModel, modelIntensities, getModelsByProvider } from "../config.js";
 import { drawHeader } from "../header.js";
 import { drawHint, drawTabButton, inRect } from "../ui.js";
 const LIST_TOP = 5;
@@ -30,7 +30,12 @@ export class ModelSelectScreen extends Screen {
             return this.providers;
         if (this.level === 1)
             return (this.modelMap[this.providers[this.selectedProviderIdx]] ?? []).map((m) => m.name);
-        return INTENSITY_LEVELS;
+        return this.currentIntensities();
+    }
+    /** Only the intensity names this exact model accepts. */
+    currentIntensities() {
+        const models = this.modelMap[this.providers[this.selectedProviderIdx]] ?? [];
+        return modelIntensities(models[this.selectedModelIdx]);
     }
     currentIdx() {
         if (this.level === 0)
@@ -73,8 +78,12 @@ export class ModelSelectScreen extends Screen {
         }
         if (this.level === 1) {
             const models = this.modelMap[this.providers[this.selectedProviderIdx]] ?? [];
-            if (models.length === 0)
+            const model = models[this.selectedModelIdx];
+            if (!model)
                 return;
+            // Start on the level in use when this model accepts it, otherwise on the
+            // model's own fallback (High, or the first level it declares).
+            this.selectedIntensityIdx = Math.max(0, this.currentIntensities().indexOf(intensityForModel(model, this.app.state.selectedIntensity)));
             this.level = 2;
             this.scrollBtn = 0;
             this.app.render();
@@ -85,7 +94,9 @@ export class ModelSelectScreen extends Screen {
         const model = models[this.selectedModelIdx];
         if (!model)
             return;
-        const intensity = INTENSITY_LEVELS[this.selectedIntensityIdx];
+        const intensity = this.currentIntensities()[this.selectedIntensityIdx];
+        if (!intensity)
+            return;
         this.app.setModelConfig(providerName, model, intensity);
         this.app.popScreen();
     }

package/dist/screens/settings.js

@@ -1,13 +1,16 @@
 import { Screen } from "../terminal/screen.js";
 import { C } from "../colors.js";
-import { CONTEXT_WINDOW_OPTIONS, DEFAULT_CONTEXT_WINDOW, contextWindow, CONFIG_FILE, INTENSITY_LEVELS, getModelsByProvider, loadConfig, loadModels, saveConfig, saveModels, } from "../config.js";
+import { CONTEXT_WINDOW_OPTIONS, DEFAULT_CONTEXT_WINDOW, contextWindow, CONFIG_FILE, INTENSITY_LEVELS, intensityForModel, modelIntensities, getModelsByProvider, loadConfig, loadModels, saveConfig, saveModels, } from "../config.js";
 import { drawHeader } from "../header.js";
 import { centerVertically, drawHint } from "../ui.js";
 import { hashWebPassword } from "../web/auth.js";
+import { runningBackground } from "../background.js";
 /** The settings that can be changed here, top to bottom. */
-const ROWS = ["intensity", "compress", "approval_model", "extreme_approval", "sound", "web_console", "web_password"];
+const ROWS = ["intensity", "compress", "approval_model", "extreme_approval", "sound", "web_console", "background", "web_password"];
 export class SettingsScreen extends Screen {
     intensityIdx = 2;
+    /** Levels the current chat model accepts, in canonical order. */
+    intensityLevels = [...INTENSITY_LEVELS];
     contextTokens = DEFAULT_CONTEXT_WINDOW;
     contextChanged = false;
     /** 0 = same model as the chat, otherwise index + 1 into `models`. */
@@ -18,8 +21,11 @@ export class SettingsScreen extends Screen {
     soundIdx = 1;
     /** 0 = web UI off, 1 = mounted alongside the terminal. */
     webIdx = 1;
+    /** 0 = terminal only, 1 = the Web console is run by a detached service. */
+    backgroundIdx = 0;
     /** Only a row the user actually touched rewrites the saved default. */
     webChanged = false;
+    backgroundPending = false;
     models = [];
     rowIdx = 0;
     lastHoverX = -1;
@@ -29,11 +35,11 @@ export class SettingsScreen extends Screen {
     passwordMessage = "Press Enter to change";
     onActivate() {
         const config = loadConfig();
-        const current = String(config.default_intensity ?? "High");
-        const i = INTENSITY_LEVELS.indexOf(current);
-        this.intensityIdx = i >= 0 ? i : 2;
         const state = this.app.state;
         const model = getModelsByProvider()[state.selectedProvider]?.find((m) => m.name === state.selectedModelName);
+        this.intensityLevels = modelIntensities(model);
+        const current = intensityForModel(model, config.default_intensity);
+        this.intensityIdx = Math.max(0, this.intensityLevels.indexOf(current));
         this.contextTokens = contextWindow(model?.context_window);
         this.contextChanged = false;
         this.models = Object.values(getModelsByProvider()).flatMap((list) => list.map((m) => m.name));
@@ -46,6 +52,9 @@ export class SettingsScreen extends Screen {
         // off, so reflect what is actually running first.
         this.webIdx = (this.app.state.webUrl || config.web_console !== false) ? 1 : 0;
         this.webChanged = false;
+        const background = runningBackground();
+        this.backgroundIdx = (state.webUrl ? state.webBackground : background?.resident ?? config.background === true) ? 1 : 0;
+        this.backgroundPending = false;
     }
     /** Change the value of a row by `delta` steps and persist it immediately. */
     cycle(row, delta) {
@@ -56,7 +65,7 @@ export class SettingsScreen extends Screen {
             return;
         }
         if (row === "intensity") {
-            const n = INTENSITY_LEVELS.length;
+            const n = this.intensityLevels.length;
             this.intensityIdx = (this.intensityIdx + delta + n) % n;
         }
         else if (row === "approval_model") {
@@ -79,6 +88,13 @@ export class SettingsScreen extends Screen {
             void this.app.setWebConsole(this.webIdx === 1);
             return;
         }
+        else if (row === "background") {
+            if (this.backgroundPending)
+                return;
+            const service = runningBackground();
+            const current = this.app.state.webUrl ? this.app.state.webBackground : service?.resident ?? this.backgroundIdx === 1;
+            return this.applyBackground(!current);
+        }
         else {
             const options = [...new Set([...CONTEXT_WINDOW_OPTIONS, this.contextTokens])].sort((a, b) => a - b);
             const i = options.indexOf(this.contextTokens);
@@ -87,6 +103,23 @@ export class SettingsScreen extends Screen {
         }
         this.save();
     }
+    async applyBackground(enabled) {
+        this.backgroundPending = true;
+        this.app.render();
+        try {
+            const result = await this.app.setBackgroundResidency(enabled);
+            if (result.ok)
+                this.backgroundIdx = enabled ? 1 : 0;
+            else
+                this.backgroundIdx = loadConfig().background === true ? 1 : 0;
+            if (this.app.state.webUrl)
+                this.webIdx = 1;
+        }
+        finally {
+            this.backgroundPending = false;
+            this.app.render();
+        }
+    }
     onKey(key) {
         if (this.editingPassword) {
             if (key.name === "escape") {
@@ -210,7 +243,7 @@ export class SettingsScreen extends Screen {
     }
     rowTexts() {
         return [
-            { label: "Default intensity", value: INTENSITY_LEVELS[this.intensityIdx] },
+            { label: "Default intensity", value: this.intensityLevels[this.intensityIdx] },
             { label: "Model context (80%)", value: `${this.contextTokens.toLocaleString("en-US")} tokens` },
             {
                 label: "Approval reviewer model",
@@ -231,9 +264,19 @@ export class SettingsScreen extends Screen {
                 value: this.webIdx === 0
                     ? "Off"
                     : this.app.state.webUrl
-                        ? `On · ${this.app.state.webUrl}`
+                        ? this.app.state.webBackground
+                            ? `On (background) · ${this.app.state.webUrl}`
+                            : `On · ${this.app.state.webUrl}`
                         : "On (not running)",
             },
+            {
+                label: "Background residency",
+                value: this.backgroundPending
+                    ? "Applying…"
+                    : this.app.state.webUrl
+                        ? this.app.state.webBackground ? "On (running)" : "Off"
+                        : runningBackground()?.resident ? "On (running)" : this.backgroundIdx === 1 ? "On (not running)" : "Off",
+            },
             {
                 label: "Web password",
                 value: this.editingPassword ? "*".repeat(Math.min(this.passwordDraft.length, 24)) || "Type new password" : this.passwordMessage,
@@ -255,7 +298,7 @@ export class SettingsScreen extends Screen {
     }
     save() {
         const config = loadConfig();
-        config.default_intensity = INTENSITY_LEVELS[this.intensityIdx];
+        config.default_intensity = this.intensityLevels[this.intensityIdx] ?? "High";
         if (this.contextChanged) {
             const data = loadModels();
             const state = this.app.state;

package/dist/screens/start.js

@@ -2,7 +2,7 @@ import { Screen } from "../terminal/screen.js";
 import { C } from "../colors.js";
 import { loadLogo, loadVersion, loadConfig, saveConfig, normalizeApprovalMode } from "../config.js";
 import { drawHeader } from "../header.js";
-import { centerVertically, computeInputWindow, cursorFromColumn, drawHint, drawInputBox, drawTabButton, inRect, approvalToggle, drawApprovalToggle, } from "../ui.js";
+import { centerVertically, computeInputWindow, cursorFromColumn, drawHint, drawInputBox, drawTabButton, inRect, approvalToggle, drawApprovalToggle, drawProModeButton, proModeButton, } from "../ui.js";
 const TABS = ["Model", "History", "Settings"];
 const LOGO = loadLogo();
 const FOCUS_COUNT = TABS.length + 2; // input box + 3 tabs + approval mode
@@ -30,6 +30,7 @@ export class StartScreen extends Screen {
     cursor = 0;
     focusIdx = 0; // 0 = input box, 1..3 = tabs, 4 = approval mode
     hoverIdx = -1; // -1 = nothing, otherwise the control index
+    proHover = false; // pointer is over the Pro-mode button
     lastHoverX = -1;
     lastHoverY = -1;
     showsCursor() {
@@ -136,23 +137,30 @@ export class StartScreen extends Screen {
                 return;
             this.lastHoverX = ev.x;
             this.lastHoverY = ev.y;
+            const pro = proModeButton(this.app.width, this.app.height);
+            const proHover = pro !== null && inRect(ev.x, ev.y, pro);
             const layout = this.layout();
             let hover = -1;
-            if (inRect(ev.x, ev.y, approvalToggle(this.app.width, this.app.height - 4, this.approvalMode))) {
-                hover = FOCUS_COUNT - 1;
-            }
-            else if (layout && inRect(ev.x, ev.y, { x: layout.inputX, y: layout.inputY, w: layout.inputW, h: INPUT_H })) {
-                hover = 0;
-            }
-            else if (layout && ev.y >= layout.tabY && ev.y < layout.tabY + TAB_H) {
-                for (let i = 0; i < layout.tabs.length; i++) {
-                    if (inRect(ev.x, ev.y, { x: layout.tabs[i].x, y: layout.tabY, w: layout.tabs[i].w, h: TAB_H })) {
-                        hover = i + 1;
-                        break;
+            // While the pointer is over the Pro button no other control is hovered
+            // underneath it: the box is opaque, so its neighbours must not light up.
+            if (!proHover) {
+                if (inRect(ev.x, ev.y, approvalToggle(this.app.width, this.app.height - 4, this.approvalMode))) {
+                    hover = FOCUS_COUNT - 1;
+                }
+                else if (layout && inRect(ev.x, ev.y, { x: layout.inputX, y: layout.inputY, w: layout.inputW, h: INPUT_H })) {
+                    hover = 0;
+                }
+                else if (layout && ev.y >= layout.tabY && ev.y < layout.tabY + TAB_H) {
+                    for (let i = 0; i < layout.tabs.length; i++) {
+                        if (inRect(ev.x, ev.y, { x: layout.tabs[i].x, y: layout.tabY, w: layout.tabs[i].w, h: TAB_H })) {
+                            hover = i + 1;
+                            break;
+                        }
                     }
                 }
             }
-            if (hover !== this.hoverIdx) {
+            if (proHover !== this.proHover || hover !== this.hoverIdx) {
+                this.proHover = proHover;
                 this.hoverIdx = hover;
                 this.app.render();
             }
@@ -164,6 +172,13 @@ export class StartScreen extends Screen {
                 return;
             if (ev.button === 2)
                 return; // right click: no-op on start screen
+            // The Pro button is a control of its own and is checked first: a left
+            // click anywhere in its box opens Pro mode instead of the control below.
+            const pro = proModeButton(this.app.width, this.app.height);
+            if (ev.button === 0 && pro && inRect(ev.x, ev.y, pro)) {
+                void this.app.openProMode();
+                return;
+            }
             if (ev.y >= 1 && inRect(ev.x, ev.y, approvalToggle(this.app.width, this.app.height - 4, this.approvalMode))) {
                 this.focusIdx = FOCUS_COUNT - 1;
                 this.toggleApproval();
@@ -209,6 +224,11 @@ export class StartScreen extends Screen {
         for (let y = inputY; y <= tabY + TAB_H; y++)
             if (y >= 0 && y < h)
                 rows.push(y);
+        // The Pro button sits directly below the status bar; repainting its rows
+        // makes it self-heal exactly like the input box and the tabs.
+        for (let y = 1; y <= 3; y++)
+            if (y >= 0 && y < h)
+                rows.push(y);
         if (h - 4 >= 1)
             rows.push(h - 4);
         return rows;
@@ -222,7 +242,7 @@ export class StartScreen extends Screen {
         const gap = 1;
         const logoGap = logoLines.length ? 1 : 0;
         const contentH = logoLines.length + logoGap + INPUT_H + gap + TAB_H;
-        const inputY = centerVertically(h - 4, contentH) + logoLines.length + logoGap;
+        const inputY = this.contentTop(h, contentH) + logoLines.length + logoGap;
         const tabY = inputY + INPUT_H + gap;
         const tabGap = 2;
         const tabInner = inputW - tabGap * (TABS.length - 1);
@@ -237,6 +257,16 @@ export class StartScreen extends Screen {
         }
         return { inputX, inputY, inputW, tabY, tabs };
     }
+    /**
+     * First content row. The centered block normally floats in the middle, but
+     * it must start below the Pro button when that button is visible: the box is
+     * opaque chrome and would otherwise clip the top of the logo.
+     */
+    contentTop(height, contentH) {
+        const top = centerVertically(height - 4, contentH);
+        const pro = proModeButton(this.app.width, height);
+        return pro ? Math.max(top, pro.y + pro.h) : top;
+    }
     move(delta) {
         this.focusIdx = (this.focusIdx + delta + FOCUS_COUNT) % FOCUS_COUNT;
         this.hoverIdx = -1;
@@ -280,7 +310,7 @@ export class StartScreen extends Screen {
         const gap = 1;
         const logoGap = logoLines.length ? 1 : 0;
         const contentH = logoLines.length + logoGap + INPUT_H + gap + TAB_H;
-        const top = centerVertically(h - 4, contentH);
+        const top = this.contentTop(h, contentH);
         let y = top;
         for (const line of logoLines) {
             buf.writeText(logoX, y, line, { fg: C.accent, bold: true });
@@ -323,5 +353,8 @@ export class StartScreen extends Screen {
             buf.centerText(versionY, `v${version}`, { fg: C.dim });
         }
         drawApprovalToggle(buf, approvalY, this.approvalMode, this.focusIdx === FOCUS_COUNT - 1 || this.hoverIdx === FOCUS_COUNT - 1);
+        // Painted last so its opaque footprint is never clipped by the decorative
+        // content above it. Its hit box uses the same top-left geometry.
+        drawProModeButton(buf, this.proHover);
     }
 }

package/dist/state.js

@@ -11,6 +11,7 @@ export function defaultState() {
         cursorOn: true,
         approval: null,
         webUrl: null,
+        webBackground: false,
         selection: null,
     };
 }