@xingjisoft/neutrino 0.3.0 → 0.4.0

package/dist/web/session.js

@@ -11,9 +11,12 @@
  * (snapshot, stream, pause, resume, message) work unchanged.
  */
 import { randomUUID } from "node:crypto";
-import { findModel, contextCompressionThreshold, loadConfig, loadPlannerPrompt, loadStepPrompt, loadSubAgentPrompt, normalizeApprovalMode, planFirstEnabled, loadModels, loadPrompt, saveSession, } from "../config.js";
+import { findModel, contextCompressionThreshold, intensityForModel, loadConfig, loadPlannerPrompt, loadStepPrompt, loadSubAgentPrompt, normalizeApprovalMode, planFirstEnabled, loadModels, loadPrompt, saveSession, } from "../config.js";
 import { COMPACT_KEEP, planCompaction, transcriptFor, modelHistory, normalizeContext, } from "../compact.js";
 import { LLMClient, describeError } from "../llm/client.js";
+import { defaultProPreset, loadProModels, loadProPrompt, proMaxRecursionDepth, requireProPreset } from "../pro/config.js";
+import { resolveProTeam, ProPreflightError } from "../pro/preflight.js";
+import { ProAgentTeam, getProToolDefinitions } from "../pro/agents.js";
 import { advancePlan, buildPlannerInput, lastRequestText, needsPlan, parsePlan, planMessage, planTranscript, renderStepDirective, resumePlan, stopPlan, } from "../llm/plan.js";
 import { DELEGATE_TOOL, executeTool, getSubAgentToolDefinitions, getToolDefinitions } from "../llm/tools.js";
 import { buildSubAgentTask, formatSubAgentResult, runSubAgent as runSubAgentTask, } from "../llm/subagent.js";
@@ -44,7 +47,7 @@ export function newSessionId(now = new Date()) {
  * written to disk until the first message, so an abandoned new-chat dialog
  * cannot litter the history with empty transcripts.
  */
-export function createWebSession(cwd, selection, approvalMode) {
+export function createWebSession(cwd, selection, approvalMode, mode = "standard", proPreset) {
     const now = new Date();
     const source = {
         id: newSessionId(now),
@@ -57,9 +60,23 @@ export function createWebSession(cwd, selection, approvalMode) {
         title: "",
         messages: [],
         tokens: { prompt: 0, completion: 0 },
-        approval_mode: normalizeApprovalMode(approvalMode ?? loadConfig().approval_mode),
+        approval_mode: normalizeApprovalMode(approvalMode ?? loadConfig(mode).approval_mode),
+        ...(mode === "pro" ? { pro_preset: requireProPreset(proPreset ?? defaultProPreset()) } : {}),
+    };
+    return new WebSession(source, selection.model, mode);
+}
+/** A preset may need fallback; defer model credentials/availability to preflight. */
+export function proInitialSelection(preset = defaultProPreset()) {
+    const tier = loadProModels().tier.find((entry) => entry.name === requireProPreset(preset));
+    const setting = tier["model-setting"].find((entry) => entry.type === "main_model");
+    const provider = setting?.provider ?? "";
+    const name = setting?.model ?? "";
+    const model = loadModels().providers.find((entry) => entry.name === provider)?.models.find((entry) => entry.name === name);
+    return {
+        provider,
+        model: model ? { ...model } : { name, url: "", api_key: "", supports_streaming: true },
+        intensity: setting?.intensity || "high",
     };
-    return new WebSession(source, selection.model);
 }
 function parseArguments(raw) {
     const text = raw?.trim() ?? "";
@@ -93,15 +110,27 @@ export function resolveModel(modelName, providerName) {
     return { ok: true, model };
 }
 /** Build a web session from a saved transcript, or explain why we cannot. */
-export function resumeSession(source, selection) {
+export function resumeSession(source, selection, mode = "standard") {
+    if (mode === "pro") {
+        try {
+            const initial = proInitialSelection(source.pro_preset ?? defaultProPreset());
+            return { ok: true, session: new WebSession({ ...source, provider: initial.provider,
+                    model: initial.model.name, intensity: initial.intensity }, initial.model, mode) };
+        }
+        catch (error) {
+            return { ok: false, error: describeError(error) };
+        }
+    }
     const updated = selection ? { ...source, ...selection } : source;
     const resolved = resolveModel(updated.model, updated.provider);
     if (!resolved.ok)
         return resolved;
-    return { ok: true, session: new WebSession(updated, resolved.model) };
+    return { ok: true, session: new WebSession(updated, resolved.model, mode) };
 }
 export class WebSession {
     key = null;
+    /** Workspace this conversation belongs to; keeps Pro and standard separate. */
+    mode;
     model;
     provider;
     intensity;
@@ -120,6 +149,10 @@ export class WebSession {
     plan = null;
     /** True while the planner agent is writing the steps. */
     planning = false;
+    proPreset = null;
+    proTeam = null;
+    proState;
+    proAbort = null;
     /** What the sub-agent is doing, or null when none is running. */
     subagent = null;
     saveError = null;
@@ -138,11 +171,16 @@ export class WebSession {
     pendingApproval = null;
     /** Reviewer count while an automated review runs, null otherwise. */
     reviewing = null;
-    constructor(source, model) {
+    constructor(source, model, mode = "standard") {
+        this.mode = mode;
+        if (mode === "pro")
+            this.proPreset = requireProPreset(source.pro_preset ?? defaultProPreset());
         this.model = model;
-        this.approvalMode = normalizeApprovalMode(source.approval_mode ?? loadConfig().approval_mode);
+        this.approvalMode = normalizeApprovalMode(source.approval_mode ?? loadConfig(this.mode).approval_mode);
         this.provider = source.provider;
-        this.intensity = source.intensity;
+        // A transcript saved before the model's limits existed (or before the model
+        // itself was narrowed) must not replay an unsupported sampling level.
+        this.intensity = mode === "pro" ? source.intensity : intensityForModel(model, source.intensity, loadConfig(this.mode).default_intensity);
         this.dir = source.cwd;
         this.sessionId = source.id;
         this.messages = source.messages.slice();
@@ -167,6 +205,7 @@ export class WebSession {
         if (this.disposed)
             return;
         this.disposed = true;
+        this.proAbort?.abort();
         this.turnToken++;
         this.busy = false;
         if (this.pendingApproval) {
@@ -183,6 +222,8 @@ export class WebSession {
         return this.dir;
     }
     liveConfigure(selection) {
+        if (this.mode === "pro")
+            return { ok: false, error: "choose a Pro preset to change professional models" };
         if (this.disposed)
             return { ok: false, error: "this session has ended" };
         if (this.busy || this.pendingApproval) {
@@ -190,13 +231,37 @@ export class WebSession {
         }
         this.model = { ...selection.model };
         this.provider = selection.provider;
-        this.intensity = selection.intensity;
+        this.intensity = intensityForModel(this.model, selection.intensity, loadConfig(this.mode).default_intensity);
         this.save();
         this.publishLive();
         return { ok: true };
     }
+    liveSetProPreset(preset) {
+        if (this.mode !== "pro" || this.disposed)
+            return { ok: false, error: "this is not an active Pro session" };
+        if (this.busy || this.pendingApproval)
+            return { ok: false, error: "pause the current turn before changing presets" };
+        try {
+            this.proPreset = requireProPreset(preset);
+            const initial = proInitialSelection(this.proPreset);
+            this.model = initial.model;
+            this.provider = initial.provider;
+            this.intensity = initial.intensity;
+            this.proTeam = null;
+            this.proState = undefined;
+            this.save();
+            this.publishLive();
+            return { ok: true };
+        }
+        catch (error) {
+            return { ok: false, error: describeError(error) };
+        }
+    }
     liveMeta() {
         return {
+            ...(this.mode === "pro" ? { pro: this.proState ?? {
+                    preset: this.proPreset, checking: false, checkId: "", models: [], fallbacks: [],
+                } } : {}),
             sessionId: this.sessionId,
             title: this.title(),
             provider: this.provider,
@@ -251,6 +316,7 @@ export class WebSession {
         if (this.paused || (!this.busy && !this.queued))
             return;
         this.paused = true;
+        this.proAbort?.abort();
         this.turnToken++;
         // A queued decision would otherwise keep the promise (and the gate) alive.
         if (this.pendingApproval) {
@@ -261,6 +327,13 @@ export class WebSession {
         this.busy = false;
         this.retainStreamingContent();
         this.subagent = null;
+        if (this.proState)
+            this.proState.checking = false;
+        if (this.mode === "pro") {
+            this.reviewing = null;
+            this.retrying = null;
+            this.planning = false;
+        }
         stopPlan(this.plan);
         this.save();
         this.publishLive();
@@ -307,6 +380,9 @@ export class WebSession {
             return;
         if (!this.checkpoint.flush())
             return;
+        this.proAbort?.abort();
+        this.proTeam = null;
+        this.proState = undefined;
         this.turnToken++;
         if (this.pendingApproval) {
             const pending = this.pendingApproval;
@@ -374,6 +450,8 @@ export class WebSession {
      * pass, exactly as it did before planning existed.
      */
     async runTurn(token, turnMessages, approvalContext) {
+        if (this.mode === "pro")
+            return this.runProTurn(token, turnMessages, approvalContext);
         await this.autoCompress(token);
         if (token !== this.turnToken || this.paused)
             return;
@@ -405,6 +483,127 @@ export class WebSession {
         }
         this.onTurnFinished();
     }
+    /** Freeze one resolved team per task, plan first, then give the whole brief to main. */
+    async runProTurn(token, turnMessages, approvalContext) {
+        const cancelled = () => token !== this.turnToken || this.paused || this.disposed;
+        const controller = new AbortController();
+        this.proAbort = controller;
+        this.proTeam = null;
+        this.plan = null;
+        this.proState = { preset: this.proPreset, checking: true, checkId: randomUUID(), models: [], fallbacks: [] };
+        this.publishLive();
+        try {
+            const resolved = await resolveProTeam(this.proPreset, {
+                signal: controller.signal,
+                onUsage: (usage) => {
+                    if (!cancelled()) {
+                        this.tokens.prompt += usage.prompt;
+                        this.tokens.completion += usage.completion;
+                    }
+                },
+            });
+            if (cancelled())
+                return;
+            this.proState.models = Object.values(resolved.models).map((entry) => ({
+                role: entry.role, provider: entry.provider, model: entry.model.name, intensity: entry.intensity, tier: entry.tier,
+            }));
+            this.proState.fallbacks = resolved.fallbacks;
+            this.proState.checking = false;
+            const team = new ProAgentTeam({
+                models: resolved.models, maxDepth: proMaxRecursionDepth(), cwd: this.dir, cancelled,
+                approve: (name, args) => this.requestApproval(name, args, {
+                    ...approvalContext, context: captureApprovalContext(this.turnView(turnMessages)).context,
+                }),
+                execute: (name, args) => executeTool(name, args, this.dir),
+                onProgress: (label) => { if (!cancelled()) {
+                    this.subagent = label;
+                    this.publishLive();
+                } },
+                onUsage: (usage) => {
+                    if (!cancelled()) {
+                        this.tokens.prompt += usage.prompt;
+                        this.tokens.completion += usage.completion;
+                    }
+                },
+                onRetry: (notice) => { if (!cancelled()) {
+                    this.retrying = notice;
+                    this.publishLive();
+                } },
+            });
+            this.proTeam = team;
+            const main = resolved.models.main_model;
+            this.model = main.model;
+            this.provider = main.provider;
+            this.intensity = main.intensity;
+            this.publishLive();
+            this.planning = true;
+            this.publishLive();
+            const planning = await team.call("plan_model", buildPlannerInput({
+                request: approvalContext.prompt, cwd: this.dir, transcript: planTranscript(turnMessages),
+            }), "Plan the task before execution. Do not modify files or execute commands.", 0, true);
+            if (cancelled())
+                return;
+            this.planning = false;
+            this.subagent = null;
+            this.retrying = null;
+            if (!planning.trim() || /\[Error:|\[Sub-agent .*without.*report/.test(planning)) {
+                throw new Error(`Pro planning failed: ${planning}`);
+            }
+            this.plan = parsePlan(planning);
+            if (!this.plan) {
+                // Standard planning skips single actions; Pro plans every task.
+                try {
+                    const single = JSON.parse(planning.trim().replace(/^```(?:json)?\s*|\s*```$/g, ""));
+                    if (single.steps?.length === 1 && typeof single.steps[0].title === "string" && single.steps[0].title.trim()) {
+                        this.plan = { goal: String(single.goal ?? "").slice(0, 240), steps: [{
+                                    title: single.steps[0].title.slice(0, 160), detail: String(single.steps[0].detail ?? "").slice(0, 400), status: "pending",
+                                }] };
+                    }
+                }
+                catch { /* A useful prose plan can still guide the main agent. */ }
+            }
+            await this.autoCompress(token);
+            if (cancelled())
+                return;
+            this.messages.push({ role: "assistant", content: this.plan ? planMessage(this.plan) : planning });
+            this.save();
+            this.publishLive();
+            const directive = `The planning agent produced this plan for the current user request:\n${planning}\n\n` +
+                "Execute the complete task, using the appropriate professional agents for reasoning, frontend, backend and modeling work. Verify the result and report the outcome.";
+            if (this.plan?.steps.length)
+                this.setStep(0, "active");
+            const finished = await this.agentLoop(this.buildApiMessages(this.turnView(turnMessages), directive), token, approvalContext);
+            if (cancelled())
+                return;
+            if (this.plan) {
+                if (finished)
+                    for (let i = 0; i < this.plan.steps.length; i++)
+                        this.setStep(i, "done");
+                else
+                    this.setStep(0, "failed");
+            }
+        }
+        catch (error) {
+            if (cancelled())
+                return;
+            this.proState.checking = false;
+            this.proState.error = describeError(error);
+            if (error instanceof ProPreflightError)
+                this.proState.fallbacks = error.fallbacks;
+            throw error;
+        }
+        finally {
+            if (!cancelled()) {
+                this.planning = false;
+                this.subagent = null;
+                this.retrying = null;
+                this.proState.checking = false;
+                this.publishLive();
+            }
+        }
+        if (!cancelled())
+            this.onTurnFinished();
+    }
     /**
      * The transcript this turn may see: the messages it started with plus what it
      * added since. A user message queued while the turn runs belongs to the next
@@ -430,7 +629,7 @@ export class WebSession {
      * a plan must improve a turn, never be a new way for one to fail.
      */
     async makePlan(token) {
-        if (!planFirstEnabled())
+        if (!planFirstEnabled(this.mode))
             return null;
         const request = lastRequestText(this.messages);
         if (!request.trim())
@@ -488,8 +687,9 @@ export class WebSession {
     buildApiMessages(messages = this.messages, directive = "") {
         // A step directive extends the system prompt: the plan is an instruction, not
         // something the user just said.
+        const prompt = this.mode === "pro" ? loadProPrompt("main_model") : loadPrompt();
         const api = [
-            { role: "system", content: directive ? `${loadPrompt()}\n\n${directive}` : loadPrompt() },
+            { role: "system", content: directive ? `${prompt}\n\n${directive}` : prompt },
         ];
         for (const m of modelHistory(messages, this.context)) {
             if (m.role === "user" || m.role === "assistant") {
@@ -507,12 +707,13 @@ export class WebSession {
      * the caller owns the turn's end because a planned turn runs this per step.
      */
     async agentLoop(apiMessages, token, approvalContext) {
-        const tools = getToolDefinitions();
+        const tools = this.mode === "pro" ? getProToolDefinitions() : getToolDefinitions();
+        const team = this.proTeam;
         try {
             for (let round = 0; round < MAX_TOOL_ROUNDS; round++) {
                 if (token !== this.turnToken || this.paused)
                     return false;
-                const client = new LLMClient(this.model, this.provider, this.intensity);
+                const client = team ? team.client("main_model") : new LLMClient(this.model, this.provider, this.intensity);
                 let text = "";
                 this.streamingContent = "";
                 this.publishLive();
@@ -552,6 +753,7 @@ export class WebSession {
                         role: "assistant",
                         content: text,
                         reasoning_content: client.reasoningContent ?? "",
+                        ...(client.anthropicContent.length ? { anthropic_content: client.anthropicContent } : {}),
                         ...(toolCalls.length > 0
                             ? {
                                 tool_calls: toolCalls.map((call) => ({
@@ -565,8 +767,13 @@ export class WebSession {
                 }
                 this.save();
                 this.publishLive();
-                if (toolCalls.length === 0)
-                    break;
+                if (toolCalls.length === 0) {
+                    if (this.mode === "pro" && !text.trim()) {
+                        this.messages.push({ role: "assistant", content: "[Error: Pro main model returned an empty completion.]" });
+                        return false;
+                    }
+                    return !/\[Error:/.test(text);
+                }
                 for (const call of toolCalls) {
                     if (token !== this.turnToken || this.paused)
                         return false;
@@ -618,7 +825,9 @@ export class WebSession {
                 }
                 this.save();
             }
-            return true;
+            if (this.mode === "pro")
+                this.messages.push({ role: "assistant", content: "[Error: Pro main agent reached its tool round limit before completion.]" });
+            return false;
         }
         catch (err) {
             if (token !== this.turnToken)
@@ -652,15 +861,28 @@ export class WebSession {
         const risk = assessToolCall(tool, args, this.dir);
         if (!risk)
             return { approved: true, source: "prompt", reason: "routine call" };
+        const approvalToken = this.turnToken;
+        const team = this.proTeam;
         const gate = new ApprovalGate({
             askHuman: () => new Promise((resolve) => {
+                if (this.mode === "pro" && (approvalToken !== this.turnToken || this.paused || this.disposed)) {
+                    resolve(false);
+                    return;
+                }
                 this.pendingApproval = { tool, args, risk, resolve };
                 this.publishLive();
             }),
             reviewer: () => this.reviewerModel(),
+            ...(this.mode === "pro" && team ? {
+                createReviewerClient: () => team.client("confirm_model"),
+                reviewerSystemPrompt: () => loadProPrompt("confirm_model"),
+                cancelled: () => approvalToken !== this.turnToken || this.paused || this.disposed,
+            } : {}),
             autoApprovalEnabled: () => this.approvalMode === "auto",
-            extremeAutoApprovalEnabled: () => loadConfig().auto_approve_extreme_risk === true,
+            extremeAutoApprovalEnabled: () => loadConfig(this.mode).auto_approve_extreme_risk === true,
             onReview: (info) => {
+                if (this.mode === "pro" && (approvalToken !== this.turnToken || this.paused || this.disposed))
+                    return;
                 this.reviewing = info
                     ? {
                         total: info.total, round: info.round ?? 1, rounds: info.rounds ?? 1,
@@ -674,7 +896,7 @@ export class WebSession {
     }
     /** Reviewer model: `approval_model` when set, otherwise the chat model. */
     reviewerModel() {
-        const name = String(loadConfig().approval_model ?? "").trim();
+        const name = String(loadConfig(this.mode).approval_model ?? "").trim();
         const found = name ? findModel(name) : null;
         if (found) {
             const usable = resolveModel(found.model.name, found.provider);
@@ -691,6 +913,13 @@ export class WebSession {
      * approval gate and abort signal live.
      */
     async runTool(name, args, toolMsg, token, apiMessages, approvalContext) {
+        if (this.mode === "pro" && (name === "call_pro_agent" || name === DELEGATE_TOOL)) {
+            const team = this.proTeam;
+            if (!team)
+                return "[Error: Pro models have not passed preflight]";
+            return team.call(String(args.role ?? "backend_output_model"), String(args.task ?? ""), `${typeof args.context === "string" ? args.context : ""}\n\nCurrent user request: ${approvalContext.prompt}\n` +
+                captureApprovalContext(apiMessages).context, 1);
+        }
         if (name !== DELEGATE_TOOL)
             return executeTool(name, args, this.dir);
         return this.delegate(args, toolMsg, token, apiMessages, approvalContext);
@@ -738,7 +967,14 @@ export class WebSession {
     }
     // ---- compression -----------------------------------------------------
     compressThreshold() {
-        return contextCompressionThreshold(this.provider, this.model);
+        if (this.mode === "pro") {
+            const setting = this.proState?.models.find((entry) => entry.role === "main_model");
+            const tier = loadProModels().tier.find((entry) => entry.name === setting?.tier);
+            const capacity = tier?.["model-setting"].find((entry) => entry.type === "main_model")?.context_window;
+            if (capacity)
+                return Math.max(1, Math.floor(capacity * 0.8));
+        }
+        return contextCompressionThreshold(this.provider, this.model, this.mode);
     }
     async autoCompress(token) {
         const threshold = this.compressThreshold();
@@ -760,7 +996,7 @@ export class WebSession {
         this.publishLive();
         let summary = "";
         try {
-            summary = await new LLMClient(this.model, this.provider, this.intensity).summarize(transcript, {
+            summary = await (this.proTeam?.client("main_model") ?? new LLMClient(this.model, this.provider, this.intensity)).summarize(transcript, {
                 cancelled: () => token !== this.turnToken || this.paused,
             });
         }
@@ -813,7 +1049,7 @@ export class WebSession {
         if (chat.length === 0)
             return true;
         try {
-            this.sessionId = saveSession(chat, this.model.name, this.provider, this.intensity, this.dir, this.sessionId, this.tokens, this.context, this.approvalMode, this.plan);
+            this.sessionId = saveSession(chat, this.model.name, this.provider, this.intensity, this.dir, this.sessionId, this.tokens, this.context, this.approvalMode, this.plan, this.mode, this.proPreset ?? undefined);
             this.saveError = null;
             return true;
         }

package/dist/web/settings.js

@@ -1,28 +1,58 @@
-import { DEFAULT_CONFIG, INTENSITY_LEVELS, WEB_LANGUAGES, contextWindow, isContextWindow, loadConfig, loadModels, normalizeApprovalMode, normalizeWebLanguage, resolveModelSelection, saveConfig, saveModels, } from "../config.js";
+import { DEFAULT_CONFIG, INTENSITY_LEVELS, WEB_LANGUAGES, contextWindow, intensityForModel, isContextWindow, loadConfig, loadModels, modelContextWindow, modelContextWindowKey, modelIntensities, normalizeApprovalMode, normalizeIntensity, normalizeWebLanguage, resolveModelSelection, saveConfig, saveModels, } from "../config.js";
 import { hashWebPassword, validateWebPassword } from "./auth.js";
-/** Public settings use a whitelist: API keys and cached credentials stay on disk. */
-export function getWebSettings() {
-    const config = { ...DEFAULT_CONFIG, ...loadConfig() };
-    const providers = loadModels().providers.map((provider) => ({
+import { defaultProPreset, loadProModels, proMaxRecursionDepth, requireProPreset } from "../pro/config.js";
+/**
+ * Public settings use a whitelist: API keys and cached credentials stay on disk.
+ *
+ * `mode` selects the workspace. The Pro workspace has its own defaults,
+ * language, plan and reviewer settings; the login password and the approval
+ * policy are layered in from the shared config by loadConfig(), so the two
+ * pages cannot drift apart on those.
+ */
+export function getWebSettings(mode = "standard") {
+    const config = { ...DEFAULT_CONFIG, ...loadConfig(mode) };
+    const catalog = loadModels();
+    const providers = catalog.providers.map((provider) => ({
         name: provider.name,
-        models: provider.models.map((model) => ({ name: model.name, configured: Boolean(model.api_key?.trim()), context_window: contextWindow(model.context_window) })),
+        models: provider.models.map((model) => ({
+            name: model.name,
+            configured: Boolean(model.api_key?.trim()),
+            context_window: modelContextWindow(provider.name, model, mode),
+            // The browser only offers these, so it cannot submit a level the model
+            // does not declare. Missing field = every intensity.
+            intensities: modelIntensities(model),
+        })),
     }));
     const preferred = providers.find((p) => p.name === config.selected_provider);
     const provider = preferred ?? providers.find((p) => p.models.some((m) => m.configured)) ?? providers[0];
     const model = provider?.models.find((m) => m.name === config.selected_model) ??
         provider?.models.find((m) => m.configured) ?? provider?.models[0];
-    const intensity = String(config.selected_intensity ?? config.default_intensity);
+    const configuredModel = provider && model
+        ? catalog.providers.find((p) => p.name === provider.name)?.models.find((m) => m.name === model.name) ?? null
+        : null;
+    const intensity = intensityForModel(configuredModel, config.selected_intensity ?? config.default_intensity, config.default_intensity);
     return {
+        ...(mode === "pro" ? { pro: {
+                presets: loadProModels().tier.map((preset) => ({
+                    name: preset.name, chinese_name: preset.chinese_name,
+                    "model-setting": preset["model-setting"].map((setting) => ({
+                        type: setting.type, provider: setting.provider, model: setting.model,
+                        intensity: setting.intensity, context_window: setting.context_window,
+                    })),
+                })),
+                preset: defaultProPreset(),
+                max_recursion_depth: proMaxRecursionDepth(),
+            } } : {}),
         providers,
         intensities: INTENSITY_LEVELS,
         languages: WEB_LANGUAGES.map((value) => ({ value, label: value === "zh" ? "简体中文" : "English" })),
         selection: {
             provider: provider?.name ?? "",
             model: model?.name ?? "",
-            intensity: INTENSITY_LEVELS.includes(intensity) ? intensity : "High",
+            intensity,
         },
         settings: {
-            default_intensity: String(config.default_intensity),
+            default_intensity: intensityForModel(configuredModel, config.default_intensity, "High"),
             model_context_window: model?.context_window ?? contextWindow(undefined),
             approval_model: String(config.approval_model ?? ""),
             auto_approve_extreme_risk: config.auto_approve_extreme_risk === true,
@@ -31,27 +61,49 @@ export function getWebSettings() {
             plan_first: config.plan_first !== false,
             approval_mode: normalizeApprovalMode(config.approval_mode),
             web_console: config.web_console !== false,
+            web_lan: config.web_lan === true,
         },
     };
 }
 /** Validate the complete patch before writing anything, preserving unrelated settings. */
-export function updateWebSettings(value) {
+export function updateWebSettings(value, mode = "standard") {
     if (!value || typeof value !== "object" || Array.isArray(value))
         throw new Error("invalid settings body");
     const body = value;
     if (Object.keys(body).some((key) => key !== "selection" && key !== "settings"))
         throw new Error("unknown settings field");
-    const config = loadConfig();
+    const config = loadConfig(mode);
+    // Resolve the requested model first: its declared intensities decide which
+    // default level can be saved with this patch. Settings that do not touch a
+    // model stay editable even when the catalogue is empty.
+    const chosen = body.selection !== undefined ? resolveModelSelection(body.selection, false) : undefined;
+    let target = chosen ?? null;
+    const settingsTarget = () => {
+        target ??= resolveModelSelection(getWebSettings(mode).selection, false);
+        return target;
+    };
     if (body.settings !== undefined) {
         if (!body.settings || typeof body.settings !== "object" || Array.isArray(body.settings))
             throw new Error("invalid settings");
         const patch = body.settings;
         for (const [key, val] of Object.entries(patch)) {
-            if (key === "default_intensity") {
-                if (typeof val !== "string" || !INTENSITY_LEVELS.includes(val))
+            if (key === "pro_preset" && mode === "pro") {
+                config.pro_preset = requireProPreset(val);
+            }
+            else if (key === "pro_max_recursion_depth" && mode === "pro") {
+                if (typeof val !== "number" || !Number.isSafeInteger(val) || val < 1 || val > 100) {
+                    throw new Error("Pro recursion depth must be a whole number from 1 to 100");
+                }
+                config.pro_max_recursion_depth = val;
+            }
+            else if (key === "default_intensity") {
+                const level = normalizeIntensity(val);
+                if (!level)
                     throw new Error("invalid default intensity");
-                config.default_intensity = val;
-                config.selected_intensity = val;
+                if (!modelIntensities(settingsTarget().model).includes(level))
+                    throw new Error("this model does not support that thinking intensity");
+                config.default_intensity = level;
+                config.selected_intensity = level;
             }
             else if (key === "model_context_window") {
                 if (!isContextWindow(val))
@@ -93,6 +145,11 @@ export function updateWebSettings(value) {
                     throw new Error("web console must be a boolean");
                 config.web_console = val;
             }
+            else if (key === "web_lan") {
+                if (typeof val !== "boolean")
+                    throw new Error("LAN access must be a boolean");
+                config.web_lan = val;
+            }
             else if (key === "web_password") {
                 validateWebPassword(val);
             }
@@ -101,8 +158,7 @@ export function updateWebSettings(value) {
             }
         }
     }
-    if (body.selection !== undefined) {
-        const chosen = resolveModelSelection(body.selection, false);
+    if (chosen) {
         config.selected_provider = chosen.provider;
         config.selected_model = chosen.model.name;
         config.selected_model_url = chosen.model.url;
@@ -116,12 +172,23 @@ export function updateWebSettings(value) {
         config.web_password_hash = hashWebPassword(password);
     const window = body.settings?.model_context_window;
     if (window !== undefined) {
-        const selection = body.selection ?? getWebSettings().selection;
-        const chosen = resolveModelSelection(selection, false);
-        const models = loadModels();
-        const model = models.providers.find((p) => p.name === chosen.provider).models.find((m) => m.name === chosen.model.name);
-        model.context_window = window;
-        saveModels(models);
+        const selected = settingsTarget();
+        if (mode === "pro") {
+            // Context capacity is part of a workspace's compression settings. Pro
+            // stores its own copy instead of editing the shared model catalog.
+            const current = config.model_context_windows;
+            const overrides = current && typeof current === "object" && !Array.isArray(current)
+                ? { ...current }
+                : {};
+            overrides[modelContextWindowKey(selected.provider, selected.model.name)] = window;
+            config.model_context_windows = overrides;
+        }
+        else {
+            const models = loadModels();
+            const model = models.providers.find((p) => p.name === selected.provider).models.find((m) => m.name === selected.model.name);
+            model.context_window = window;
+            saveModels(models);
+        }
     }
-    saveConfig(config);
+    saveConfig(config, mode);
 }