@xingjisoft/neutrino 0.3.0 → 0.4.0

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/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,6 +1,6 @@
 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";
@@ -8,6 +8,8 @@ import { hashWebPassword } from "../web/auth.js";
 const ROWS = ["intensity", "compress", "approval_model", "extreme_approval", "sound", "web_console", "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`. */
@@ -29,11 +31,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));
@@ -56,7 +58,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") {
@@ -210,7 +212,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",
@@ -255,7 +257,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/ui.js

@@ -293,6 +293,64 @@ export function drawTabButton(buf, x, y, w, label, selected, align = "center") {
         buf.writeText(lx, y + 1, label, { fg: C.dim });
     }
 }
+/** Label of the CLI entry point that opens the browser console's Pro workspace. */
+export const PRO_MODE_LABEL = "启用Pro模式";
+/**
+ * Geometry of the Pro-mode button: a small box in the top-left corner, directly
+ * below the status bar (row 0). Rendering and hit testing share it so a click
+ * always lands on the box that is drawn.
+ *
+ * Returns null when the terminal is too small to fit the box with a little
+ * breathing room around it. The height floor also keeps the start screen's
+ * centered block (which is pushed below the box) clear of the approval toggle
+ * on very short terminals, where the original layout is preserved instead.
+ */
+export function proModeButton(width, height) {
+    // One blank column at the very edge, then the border: "flush to the edge
+    // with a single space", as the start screen expects.
+    const x = 1;
+    const y = 1;
+    const h = 3;
+    // Two cells of padding, one inside each border.
+    const w = displayWidth(PRO_MODE_LABEL) + 4;
+    if (width < w + 4 || height < 22)
+        return null;
+    return { x, y, w, h, label: PRO_MODE_LABEL };
+}
+/**
+ * Draw the Pro-mode button. It is painted as opaque chrome so content behind it
+ * can never bleed through; the label row turns into the highlight background
+ * while the pointer is over it.
+ */
+export function drawProModeButton(buf, hovered = false) {
+    const button = proModeButton(buf.width, buf.height);
+    if (!button)
+        return;
+    const { x, y, w, h, label } = button;
+    if (w < 2 || h < 2)
+        return;
+    // Clear the footprint first: the button acts as an overlay over decorative
+    // content (the logo), which must not show through its interior.
+    buf.fillRect(x, y, w, h, { bg: C.black });
+    buf.drawBox(x, y, w, h, { fg: C.dim });
+    const innerX = x + 1;
+    const innerW = w - 2;
+    const labelY = y + Math.floor(h / 2);
+    if (hovered)
+        buf.fillRect(innerX, labelY, innerW, 1, { bg: C.highlightBg });
+    const text = truncateByWidth(label, innerW);
+    const textX = innerX + Math.max(0, Math.floor((innerW - displayWidth(text)) / 2));
+    const style = hovered
+        ? { fg: C.accent, bg: C.highlightBg, bold: true }
+        : { fg: C.accent, bold: true };
+    buf.writeText(textX, labelY, text, style);
+    // The button is chrome, not content: copying a selection across it must not
+    // drag its border or label into the clipboard.
+    for (let j = y; j < y + h; j++) {
+        for (let i = x; i < x + w; i++)
+            buf.markChrome(i, j);
+    }
+}
 export function centerVertically(totalHeight, contentHeight) {
     const top = Math.floor((totalHeight - contentHeight) / 2);
     return Math.max(1, top);

package/dist/web/hub.js

@@ -12,6 +12,7 @@
  * {@link LiveHub.notify}, which coalesces rapid-fire updates (one per streamed
  * token) and pushes a snapshot to any connected browser.
  */
+import { normalizeMode } from "../config.js";
 export function liveApprovalDetails(tool, args, risk, cwd) {
     return { tool, level: risk.level, arguments: args, cwd, summary: risk.summary, reasons: risk.reasons };
 }
@@ -32,6 +33,7 @@ class LiveHub {
             key,
             agent,
             cwd: agent.liveCwd(),
+            mode: normalizeMode(agent.mode),
             listeners: new Set(),
             timer: null,
             lastSent: "",
@@ -48,13 +50,20 @@ class LiveHub {
             clearTimeout(entry.timer);
         this.entries.delete(key);
     }
-    has(key) {
-        return this.entries.has(key);
+    /**
+     * Whether a key is live. With a mode, keys from the other workspace are
+     * treated as unknown: the Pro page must never reach a terminal session.
+     */
+    has(key, mode) {
+        const entry = this.entries.get(key);
+        return Boolean(entry) && (!mode || entry.mode === mode);
     }
-    /** All live sessions, newest registration last. */
-    list() {
+    /** All live sessions, newest registration last. Optionally one workspace only. */
+    list(mode) {
         const out = [];
         for (const entry of this.entries.values()) {
+            if (mode && entry.mode !== mode)
+                continue;
             out.push({ ...entry.agent.liveMeta(), key: entry.key, cwd: entry.cwd });
         }
         return out;
@@ -167,6 +176,15 @@ class LiveHub {
             this.notify(key);
         return result;
     }
+    setProPreset(key, preset) {
+        const entry = this.entries.get(key);
+        if (!entry?.agent.liveSetProPreset)
+            return { ok: false, error: "this session cannot change Pro presets" };
+        const result = entry.agent.liveSetProPreset(preset);
+        if (result.ok)
+            this.notify(key);
+        return result;
+    }
     setApprovalMode(key, mode) {
         const entry = this.entries.get(key);
         if (!entry?.agent.liveSetApprovalMode)