@xingjisoft/neutrino 0.3.0 → 0.4.1

package/dist/web/service.js

@@ -0,0 +1,135 @@
+import { randomBytes } from "node:crypto";
+import process from "node:process";
+import { backgroundLog, clearBackgroundStatus, isProcessAlive, writeBackgroundStatus, } from "../background.js";
+import { loadConfig, saveConfig } from "../config.js";
+import { startBackgroundTray } from "../tray.js";
+import { hub } from "./hub.js";
+import { startWebServer } from "./server.js";
+import { TerminalBridges } from "./terminalBridge.js";
+/** The detached process owns browser conversations for their entire lifetime. */
+export async function runWebService(options) {
+    const token = process.env.NEUTRINO_BACKGROUND_TOKEN?.trim() || randomBytes(32).toString("hex");
+    let resident = process.env.NEUTRINO_BACKGROUND_RESIDENT !== "0";
+    const owner = Number(process.env.NEUTRINO_BACKGROUND_OWNER);
+    let owners = new Set(Number.isSafeInteger(owner) && owner > 0 ? [owner] : []);
+    const startedAt = new Date().toISOString();
+    let handle = null;
+    let tray = null;
+    let monitor = null;
+    let stopping = false;
+    const bridges = new TerminalBridges();
+    const status = () => {
+        if (!handle)
+            throw new Error("the Web console is starting");
+        return {
+            pid: process.pid, port: handle.port, host: handle.host, url: handle.url,
+            auth_required: options.auth, token, started_at: startedAt,
+            resident, owner_pids: [...owners],
+        };
+    };
+    const syncTray = () => {
+        if (!resident) {
+            tray?.close();
+            tray = null;
+        }
+        else if (!tray && options.tray && handle) {
+            tray = startBackgroundTray({ url: handle.url, stopUrl: `${handle.url}/api/background/stop`, token, pid: process.pid });
+        }
+    };
+    const shutdown = () => {
+        if (stopping)
+            return;
+        stopping = true;
+        if (monitor)
+            clearInterval(monitor);
+        tray?.close();
+        bridges.close();
+        backgroundLog(`stopping pid=${process.pid}`);
+        clearBackgroundStatus(process.pid);
+        const finish = () => process.exit(0);
+        if (handle)
+            handle.close().finally(finish).catch(finish);
+        else
+            finish();
+        setTimeout(finish, 3000).unref();
+    };
+    const configure = (update) => {
+        if (stopping)
+            throw new Error("the Web console is shutting down");
+        if (update.ownerPid !== undefined && !isProcessAlive(update.ownerPid)) {
+            throw new Error("the terminal that owns this console has already exited");
+        }
+        const previousResident = resident;
+        const previousOwners = owners;
+        const config = loadConfig();
+        const changed = update.resident !== undefined;
+        if (changed)
+            saveConfig({ ...config, background: update.resident });
+        resident = update.resident ?? resident;
+        owners = new Set(owners);
+        if (update.ownerPid !== undefined)
+            owners.add(update.ownerPid);
+        try {
+            writeBackgroundStatus(status());
+        }
+        catch (error) {
+            resident = previousResident;
+            owners = previousOwners;
+            if (changed) {
+                try {
+                    saveConfig(config);
+                }
+                catch { /* Report the original failure. */ }
+            }
+            throw error;
+        }
+        if (update.bridge && update.ownerPid)
+            bridges.add(update.ownerPid, update.bridge);
+        syncTray();
+        return status();
+    };
+    try {
+        handle = await startWebServer({
+            port: options.port, host: options.host, auth: options.auth,
+            backgroundPrompt: !resident && process.env.NEUTRINO_BACKGROUND_PROMPT === "1",
+            backgroundService: { token, onStop: shutdown, status, configure },
+            onAddressChange: () => { if (handle)
+                writeBackgroundStatus(status()); },
+        });
+        writeBackgroundStatus(status());
+    }
+    catch (error) {
+        backgroundLog(`failed to start pid=${process.pid}: ${error instanceof Error ? error.message : String(error)}`);
+        if (handle)
+            await handle.close();
+        process.exit(1);
+    }
+    backgroundLog(`started pid=${process.pid} on ${handle.url} (residency ${resident ? "on" : "off"})`);
+    syncTray();
+    // No helper processes: polling pids must remain invisible on Windows. An
+    // orphaned, non-resident console lets an in-flight browser turn finish before
+    // exiting, so disabling residency also cannot throw away running work.
+    monitor = setInterval(() => {
+        try {
+            const live = new Set([...owners].filter(isProcessAlive));
+            if (live.size !== owners.size) {
+                for (const owner of owners)
+                    if (!live.has(owner))
+                        bridges.remove(owner);
+                owners = live;
+                writeBackgroundStatus(status());
+            }
+            if (!resident && owners.size === 0 && !hub.list().some(entry => entry.busy || entry.paused || entry.queued || entry.compressing || entry.approval || entry.reviewing)) {
+                shutdown();
+            }
+        }
+        catch (error) {
+            backgroundLog(`lifetime check failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }, 500);
+    monitor.unref();
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    if (process.platform !== "win32")
+        process.on("SIGHUP", () => { });
+}

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";
@@ -24,8 +27,6 @@ import { writeCrashLog } from "../terminal/restore.js";
 import { hub, liveApprovalDetails, } from "./hub.js";
 /** Drop a resumed conversation nobody touched for this long. */
 const IDLE_DISPOSE_MS = 30 * 60 * 1000;
-/** Upper bound on tool round-trips inside a single turn. */
-const MAX_TOOL_ROUNDS = 24;
 /** Placeholder shown while a tool is still running. */
 const TOOL_PENDING = "…";
 /** A sub-agent gets the same tools minus delegation: one level, never a tree. */
@@ -44,7 +45,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 +58,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 +108,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 +147,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 +169,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 +203,7 @@ export class WebSession {
         if (this.disposed)
             return;
         this.disposed = true;
+        this.proAbort?.abort();
         this.turnToken++;
         this.busy = false;
         if (this.pendingApproval) {
@@ -183,6 +220,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 +229,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 +314,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 +325,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 +378,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 +448,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 +481,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 +627,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 +685,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 +705,16 @@ 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++) {
+            while (true) {
                 if (token !== this.turnToken || this.paused)
                     return false;
-                const client = new LLMClient(this.model, this.provider, this.intensity);
+                // Match the terminal: long tasks can keep using tools until the model
+                // finishes, while older tool results are trimmed near the context limit.
+                apiMessages = this.trimApiMessages(apiMessages);
+                const client = team ? team.client("main_model") : new LLMClient(this.model, this.provider, this.intensity);
                 let text = "";
                 this.streamingContent = "";
                 this.publishLive();
@@ -552,6 +754,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 +768,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 +826,6 @@ export class WebSession {
                 }
                 this.save();
             }
-            return true;
         }
         catch (err) {
             if (token !== this.turnToken)
@@ -652,15 +859,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 +894,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 +911,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 +965,33 @@ 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);
+    }
+    /** Trim old tool results in a long turn without changing the saved history. */
+    trimApiMessages(apiMessages) {
+        const threshold = this.compressThreshold();
+        if (threshold <= 0 || this.lastPromptTokens < threshold)
+            return apiMessages;
+        const toolIdx = [];
+        for (let i = 0; i < apiMessages.length; i++) {
+            if (apiMessages[i].role === "tool")
+                toolIdx.push(i);
+        }
+        const dropCount = toolIdx.length - COMPACT_KEEP;
+        if (dropCount <= 0)
+            return apiMessages;
+        const copy = apiMessages.slice();
+        for (let k = 0; k < dropCount; k++) {
+            copy[toolIdx[k]] = { ...copy[toolIdx[k]], content: "[tool output omitted to save context]" };
+        }
+        return copy;
     }
     async autoCompress(token) {
         const threshold = this.compressThreshold();
@@ -760,7 +1013,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 +1066,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;
         }