smolcoder-plus 1.0.0

package/dist/session.js

@@ -0,0 +1,639 @@
+"use strict";
+// One session = one workspace + one agent + one UI, plus the input loop and
+// slash commands that drive it. Extracted from the CLI entry point so the
+// terminal TUI and the web hub (many sessions side by side, one per browser
+// sidebar entry) run exactly the same loop.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Session = exports.HOSTS_ROW = exports.FIND_ROW = exports.MODE_ORDER = exports.SLASH_COMMANDS = void 0;
+exports.outputBudget = outputBudget;
+exports.makeProvider = makeProvider;
+exports.effortAdvice = effortAdvice;
+exports.reportCompactions = reportCompactions;
+exports.autoPickModel = autoPickModel;
+exports.noBackendsMessage = noBackendsMessage;
+exports.backendLabel = backendLabel;
+exports.sessionLine = sessionLine;
+exports.fmtTokens = fmtTokens;
+exports.prepareModel = prepareModel;
+exports.modelOptions = modelOptions;
+exports.setupWithoutLocalModels = setupWithoutLocalModels;
+exports.suggestTitle = suggestTitle;
+exports.cleanTitle = cleanTitle;
+const os = __importStar(require("os"));
+const agent_1 = require("./agent");
+const config_1 = require("./config");
+const context_1 = require("./context");
+const detect_1 = require("./detect");
+const events_1 = require("./events");
+const network_1 = require("./network");
+const plan_1 = require("./plan");
+const prompt_1 = require("./prompt");
+const lmstudio_1 = require("./providers/lmstudio");
+const ollama_1 = require("./providers/ollama");
+const index_1 = require("./tools/index");
+const shell_1 = require("./tools/shell");
+const tasks_1 = require("./tools/tasks");
+const ui_1 = require("./ui");
+const util_1 = require("./util");
+exports.SLASH_COMMANDS = [
+    { name: "models", desc: "Switch model · add models from other machines" },
+    { name: "mode", desc: "Set mode (ro / edit / bypass)" },
+    { name: "effort", desc: "Set reasoning effort" },
+    { name: "plan", desc: "Show the agent's plan" },
+    { name: "context", desc: "Show context usage" },
+    { name: "compact", desc: "Compact the conversation now" },
+    { name: "tasks", desc: "List background tasks" },
+    { name: "logs", desc: "Show task output — /logs t1" },
+    { name: "stop", desc: "Stop a background task — /stop t1" },
+    { name: "clear", desc: "Reset the conversation" },
+    { name: "help", desc: "Show help" },
+    { name: "exit", desc: "Quit smolcoder (web: close this session)" },
+];
+exports.MODE_ORDER = ["ro", "edit", "bypass"];
+// ---- model selection helpers (shared with the headless path) --------------
+/** Output budget scales with the window: big windows can afford whole-file
+ * writes (a single write_file's JSON must fit in the output), tiny windows
+ * must stay conservative. */
+function outputBudget(window) {
+    return Math.max(128, Math.min(8192, Math.floor(window / 4)));
+}
+function makeProvider(m) {
+    const maxOut = outputBudget(m.contextWindow);
+    return m.backend === "ollama"
+        ? new ollama_1.OllamaProvider(m.baseUrl, m.id, m.contextWindow, m.numCtx, maxOut, m.vision)
+        : new lmstudio_1.LmStudioProvider(m.baseUrl, m.id, m.contextWindow, maxOut, m.reasoning, m.vision);
+}
+/** One-line advice when the effective reasoning setting will be slow: LM
+ * Studio applies the model's own default level when none is chosen, and for
+ * current qwen builds that default is the maximum. */
+function effortAdvice(m, effort) {
+    if (m.backend !== "lmstudio" || !m.reasoning?.default)
+        return null;
+    const d = m.reasoning.default;
+    if (effort === null && /^(high|xhigh)$/.test(d)) {
+        return `this model thinks at "${d}" by default on LM Studio — expect long pauses before each tool call. /effort off (or --effort off) is many times faster; /effort low or medium keeps some reasoning.`;
+    }
+    return null;
+}
+/** Tell the user what context management just did (both UIs; headless logs
+ * it to stderr so a long run's log shows when and how hard compaction hit). */
+function reportCompactions(bus, ui) {
+    bus.on("post_compact", (report) => {
+        const delta = `${report?.before} → ${report?.after} tokens est.`;
+        if (report?.action === "evicted")
+            ui.status(`· pruned context (${delta})`);
+        else if (report?.action === "compacted")
+            ui.status(`· compacted the conversation into hand-over notes (${delta})`);
+        else if (report?.action === "floor")
+            ui.warn(`· context is at its floor: system prompt + tools + the working tail no longer fit comfortably (${delta}). Consider a bigger context window.`);
+    });
+}
+/** `url` says which server the wanted (or else the remembered) model was on;
+ * it only breaks ties between machines that serve the same model id. */
+function autoPickModel(models, wanted, remembered, url) {
+    if (wanted) {
+        const hit = models.find((m) => m.id === wanted && m.baseUrl === url) ??
+            models.find((m) => m.id === wanted) ??
+            models.find((m) => m.id.toLowerCase().includes(wanted.toLowerCase()));
+        if (hit)
+            return hit;
+        throw new Error(`Model "${wanted}" was not found on the selected backend. Use /models to choose an available model.`);
+    }
+    // With nothing remembered, a model on this computer beats one across the network.
+    const local = models.filter((m) => !m.host);
+    const pool = local.length ? local : models;
+    return (models.find((m) => m.id === remembered && m.baseUrl === url) ??
+        models.find((m) => m.id === remembered) ??
+        pool.find((m) => m.backend === "ollama") ??
+        pool.find((m) => m.loaded) ??
+        pool[0]);
+}
+function noBackendsMessage() {
+    return (util_1.c.red("No usable model found.") +
+        `\n\nsmolcoder connects to a running model server; it does not scan installed apps or drives.\n` +
+        `  · ${util_1.c.bold("Ollama")}: start the app (or run: ollama serve), then check: ollama list\n` +
+        `    Found on this computer, at ${util_1.c.dim("$OLLAMA_HOST")}, and in Docker containers that publish its port.\n` +
+        `    If the list is empty, run: ollama pull qwen3\n` +
+        `  · ${util_1.c.bold("LM Studio")}: load a model and start Local Server in the Developer tab (any port).\n` +
+        `  · ${util_1.c.bold("Another machine")}: start smol in a terminal or with --web and choose "Find models on another machine".\n\n` +
+        `Then run smol again.`);
+}
+/** "ollama" on this computer, "ollama @ gpu-box" across the network. */
+function backendLabel(m) {
+    return m.host ? `${m.backend} @ ${m.host}` : m.backend;
+}
+function sessionLine(m, mode) {
+    return `${util_1.c.green("●")} ${backendLabel(m)} · ${util_1.c.bold(m.id)} · ctx ${m.contextWindow.toLocaleString()} · ${index_1.MODE_LABELS[mode]} mode`;
+}
+function fmtTokens(n) {
+    return n < 1000 ? String(n) : (n / 1000).toFixed(1) + "k";
+}
+function modeColored(mode) {
+    const label = index_1.MODE_LABELS[mode];
+    if (mode === "bypass")
+        return util_1.c.red(util_1.c.bold(label));
+    if (mode === "ro")
+        return util_1.c.magenta(util_1.c.bold(label));
+    return util_1.c.cyan(util_1.c.bold(label));
+}
+/** Detect backends, pick a model and resolve its context window. Returns null
+ * when no backend answers. `progress` gets a short label for each slow step. */
+async function prepareModel(prefs, cfg, progress) {
+    progress?.("looking for Ollama and LM Studio");
+    const url = prefs.model ? prefs.baseUrl : cfg.lastModelUrl;
+    // Without --model the remembered one wins anyway, so stop looking the moment
+    // it shows up instead of waiting out a network host that is switched off.
+    const until = !prefs.model && cfg.lastModel
+        ? (m) => m.id === cfg.lastModel && (!url || m.baseUrl === url) && (!prefs.backend || m.backend === prefs.backend)
+        : undefined;
+    const models = (await (0, detect_1.detectAll)({ hosts: cfg.hosts, until })).filter((m) => !prefs.backend || m.backend === prefs.backend);
+    if (models.length === 0)
+        return null;
+    const chosen = autoPickModel(models, prefs.model, cfg.lastModel, url);
+    progress?.(`loading ${chosen.id}`);
+    return (0, detect_1.resolveContextWindow)(chosen, prefs.ctx);
+}
+/** Picker rows for a model list: this computer first, then each network host. */
+function modelOptions(models, current) {
+    return models.map((m) => ({
+        label: m.id,
+        hint: (m.backend === "ollama" ? "ollama" : `lm studio${m.loaded ? ` · ctx ${m.contextWindow.toLocaleString()}` : " · not loaded"}`) +
+            (m.host ? ` · ${m.host}` : ""),
+        current: !!current && m.id === current.id && m.backend === current.backend && m.baseUrl === current.baseUrl,
+    }));
+}
+exports.FIND_ROW = { label: "+ Find models on another machine…", hint: "search my network or enter an address" };
+exports.HOSTS_ROW = { label: "Network hosts…", hint: "rename, remove or re-find added machines" };
+/** Nothing answered on this computer. Rather than giving up, offer to look on
+ * the network — with both UIs' own pickers, before a session exists. Returns
+ * a ready model, or null when the user backs out. */
+async function setupWithoutLocalModels(ui, prefs) {
+    for (;;) {
+        const pick = await ui.select("No model server found on this computer", [
+            { label: "Find models on another machine", hint: "search my network or enter an address" },
+            { label: "Look again", hint: "after starting Ollama or LM Studio here" },
+        ]);
+        if (pick === null)
+            return null;
+        if (pick === 0 && !(await (0, network_1.findModelsOnNetwork)(ui)))
+            continue;
+        ui.startSpinner("looking for Ollama and LM Studio");
+        const cfg = (0, config_1.loadConfig)();
+        const models = (await (0, detect_1.detectAll)({ hosts: cfg.hosts })).filter((m) => !prefs.backend || m.backend === prefs.backend);
+        ui.stopSpinner();
+        if (!models.length) {
+            ui.warn("Still no model server answering.");
+            continue;
+        }
+        // A machine was just added by hand: let the user say which of its models
+        // to load instead of pulling the first one into its memory.
+        const idx = models.length === 1 ? 0 : await ui.select("Select model", modelOptions(models));
+        if (idx === null)
+            continue;
+        ui.startSpinner(`loading ${models[idx].id}`);
+        try {
+            return await (0, detect_1.resolveContextWindow)(models[idx], prefs.ctx);
+        }
+        finally {
+            ui.stopSpinner();
+        }
+    }
+}
+// ---- session titles ---------------------------------------------------------
+/** Ask the model for a short session name from the first exchange. One cheap
+ * call with thinking off and a tiny output cap; null when the reply is not
+ * usable, in which case the caller keeps its fallback (the first message). */
+async function suggestTitle(messages, provider) {
+    const first = messages.find((m) => m.role === "user" && !m.compactNote);
+    if (!first)
+        return null;
+    const reply = [...messages].reverse().find((m) => m.role === "assistant" && m.content.trim());
+    try {
+        const res = await provider.chat([
+            {
+                role: "system",
+                content: "You name coding sessions. Reply with only the title: three to six words, plain text, no quotes, no trailing period.",
+            },
+            {
+                role: "user",
+                content: `First request:\n${(0, util_1.truncateEnd)(first.content, 600)}\n\n` +
+                    (reply ? `Reply excerpt:\n${(0, util_1.truncateEnd)(reply.content, 400)}\n\n` : "") +
+                    "Title:",
+            },
+        ], [], { effortOverride: "off", maxTokens: 30, timeoutMs: 15_000, background: true });
+        return cleanTitle(res.content);
+    }
+    catch {
+        return null;
+    }
+}
+/** Exported for tests: normalize a model-written title. */
+function cleanTitle(raw) {
+    let t = String(raw ?? "").replace(/<think>[\s\S]*?(<\/think>|$)/gi, "");
+    t = t.split("\n").map((l) => l.trim()).find(Boolean) ?? "";
+    t = t
+        .replace(/^(title|session( name)?)\s*:\s*/i, "")
+        .replace(/^["'`“”*#\s]+|["'`“”*.\s]+$/g, "")
+        .replace(/\s+/g, " ");
+    if (t.length < 3 || /[<>{}]/.test(t))
+        return null;
+    if (t.length > 60) {
+        t = t.slice(0, 60);
+        const cut = t.lastIndexOf(" ");
+        if (cut > 20)
+            t = t.slice(0, cut);
+        t = t.replace(/[\s,;:.-]+$/, "");
+    }
+    return t || null;
+}
+class Session {
+    ui;
+    workspace;
+    chosen;
+    effort;
+    agent;
+    toolCtx;
+    taskManager;
+    ctxMgr;
+    bus = new events_1.EventBus();
+    shell = (0, shell_1.pickShell)();
+    /** Host hook: fired once when the session has shut down (/exit, ctrl+c). */
+    onExit = null;
+    /** Host hook: fired after each completed user turn (the web hub names the
+     * session after the first one). */
+    onTurnDone = null;
+    agentsMd;
+    prefs;
+    help;
+    ended = false;
+    constructor(ui, opts) {
+        this.ui = ui;
+        const { workspace, chosen, prefs, cfg } = opts;
+        this.workspace = workspace;
+        this.chosen = chosen;
+        this.prefs = prefs;
+        this.help = opts.help;
+        const mode0 = prefs.mode ?? cfg.lastMode ?? "edit";
+        this.effort = prefs.effort !== undefined ? prefs.effort : (cfg.effort ?? null);
+        const provider = makeProvider(chosen);
+        provider.setEffort(this.effort);
+        this.taskManager = new tasks_1.TaskManager(workspace);
+        this.toolCtx = {
+            workspace,
+            taskManager: this.taskManager,
+            plan: new plan_1.Plan(),
+            filesTouched: new Set(),
+            commandsRun: [],
+        };
+        this.ctxMgr = new context_1.ContextManager(chosen.contextWindow, provider.maxOutputTokens);
+        this.agentsMd = (0, prompt_1.loadAgentsMd)(workspace);
+        // The step cap is a runaway-loop backstop, not a work limit — esc/ctrl+c
+        // is the user's real kill switch, so set it far above any legitimate task.
+        this.agent = new agent_1.Agent(provider, mode0, this.sysPrompt(mode0), this.toolCtx, this.ctxMgr, this.bus, ui, true, 1000);
+        ui.slashCommands = exports.SLASH_COMMANDS;
+        ui.hintLeft = workspace.replace(os.homedir(), "~");
+        ui.getStatus = () => this.statusLine();
+        ui.onModeCycle = () => {
+            const next = exports.MODE_ORDER[(exports.MODE_ORDER.indexOf(this.agent.mode) + 1) % exports.MODE_ORDER.length];
+            this.agent.setMode(next, this.sysPrompt(next));
+            this.persist();
+        };
+        ui.onCancel = () => this.agent.cancel();
+        ui.onExit = () => void this.shutdown();
+        reportCompactions(this.bus, ui);
+        this.bus.on("context_update", () => ui.refresh());
+        this.persist();
+    }
+    sysPrompt(mode) {
+        return (0, prompt_1.buildSystemPrompt)({ workspace: this.workspace, mode, shellLabel: this.shell.label, agentsMd: this.agentsMd });
+    }
+    persist() {
+        (0, config_1.updateConfig)({ lastModel: this.chosen.id, lastModelUrl: this.chosen.baseUrl, lastMode: this.agent.mode, effort: this.effort });
+    }
+    /** The TUI's status row: mode · model · effort · context · plan · tasks. */
+    statusLine() {
+        const agent = this.agent;
+        const tasks = this.taskManager.runningSummary().length;
+        const plan = this.toolCtx.plan;
+        return (`${modeColored(agent.mode)} ${util_1.c.dim("·")} ${this.chosen.id} ${util_1.c.dim(backendLabel(this.chosen))}` +
+            (this.effort || agent.provider.effortLabel()
+                ? ` ${util_1.c.dim("·")} ${util_1.c.yellow(agent.provider.effortLabel() ?? this.effort ?? "")}`
+                : "") +
+            ` ${util_1.c.dim("·")} ${util_1.c.dim(`${fmtTokens(agent.contextTokens())} (${agent.contextPercent()}%)`)}` +
+            (plan.exists
+                ? ` ${util_1.c.dim("·")} ${plan.currentIndex < 0
+                    ? util_1.c.green(`plan ${plan.doneCount}/${plan.steps.length}`)
+                    : util_1.c.cyan(`plan ${plan.doneCount}/${plan.steps.length}`)}`
+                : "") +
+            (tasks ? ` ${util_1.c.dim("·")} ${util_1.c.green(`${tasks} task${tasks > 1 ? "s" : ""}`)}` : ""));
+    }
+    /** Structured status for the web page's status bar. */
+    state() {
+        const plan = this.toolCtx.plan;
+        return {
+            mode: this.agent.mode,
+            model: this.chosen.id,
+            backend: this.chosen.backend,
+            host: this.chosen.host,
+            vision: this.chosen.vision,
+            effort: this.agent.provider.effortLabel() ?? this.effort,
+            ctxTokens: this.agent.contextTokens(),
+            ctxPct: this.agent.contextPercent(),
+            context: this.agent.contextBudget(),
+            outcome: this.agent.outcome,
+            lastError: this.agent.lastError,
+            plan: plan.exists ? { steps: plan.steps, current: plan.currentIndex } : null,
+            tasks: this.taskManager.runningSummary().length,
+            workspace: this.workspace,
+            commands: exports.SLASH_COMMANDS,
+            urls: this.taskManager.recentUrls(),
+        };
+    }
+    /** The opening lines: backend · model · mode, workspace, AGENTS.md, advice. */
+    announce() {
+        const ui = this.ui;
+        if (this.chosen.note)
+            ui.warn(`  ${this.chosen.note}`);
+        const advice = effortAdvice(this.chosen, this.effort);
+        if (advice)
+            ui.warn(`  ${advice}`);
+    }
+    snapshot() {
+        return {
+            messages: this.agent.messages.slice(1),
+            plan: this.toolCtx.plan.steps.map((s) => ({ ...s })),
+            filesTouched: [...this.toolCtx.filesTouched],
+            commandsRun: [...this.toolCtx.commandsRun],
+            originalRequest: this.agent.originalRequest,
+            currentRequest: this.agent.currentRequest,
+            mode: this.agent.mode,
+            effort: this.effort,
+            model: this.chosen.id,
+            backend: this.chosen.backend,
+            baseUrl: this.chosen.baseUrl,
+        };
+    }
+    /** A model-written name for this session, or null to keep the fallback. */
+    suggestTitle() {
+        return suggestTitle(this.agent.messages, this.agent.provider);
+    }
+    /** Bring a saved transcript back (the system message is rebuilt for the
+     * current mode/workspace; approvals are deliberately not restored). */
+    restore(s) {
+        this.agent.restoreTranscript(s.messages ?? [], s.originalRequest ?? "", s.currentRequest ?? "");
+        this.toolCtx.plan.steps = (s.plan ?? []).map((p) => ({ text: String(p.text), done: !!p.done,
+            ...(typeof p.note === "string" ? { note: p.note.slice(0, 1000) } : {}) }));
+        for (const f of s.filesTouched ?? [])
+            this.toolCtx.filesTouched.add(f);
+        this.toolCtx.commandsRun.push(...(s.commandsRun ?? []));
+    }
+    /** The input loop. Returns after /exit (or after the host asked the UI to
+     * hand back "/exit"). */
+    async run() {
+        const { ui, agent, toolCtx, taskManager } = this;
+        await this.bus.emit("session_start");
+        for (;;) {
+            const raw = await ui.readInput();
+            const input = typeof raw === "string" ? raw : raw.text;
+            const attachments = typeof raw === "string" ? [] : raw.attachments;
+            if (!attachments.length && input.startsWith("/")) {
+                const [cmd, ...rest] = input.slice(1).split(/\s+/);
+                const arg = rest[0];
+                switch (cmd) {
+                    case "exit":
+                    case "quit":
+                    case "q":
+                        await this.shutdown();
+                        return;
+                    case "help":
+                        ui.println(this.help);
+                        break;
+                    case "models":
+                    case "model":
+                        await this.switchModel();
+                        break;
+                    case "mode":
+                        await this.setMode(arg);
+                        break;
+                    case "effort":
+                        await this.setEffort(arg);
+                        break;
+                    case "plan":
+                        if (toolCtx.plan.exists)
+                            ui.println((0, ui_1.renderPlan)(toolCtx.plan));
+                        else
+                            ui.status("· no plan yet — the agent creates one when it starts a multi-step task");
+                        break;
+                    case "tasks":
+                        ui.println(taskManager.list());
+                        break;
+                    case "logs":
+                        ui.println(taskManager.logs(arg ?? "", Number(rest[1]) || 50));
+                        break;
+                    case "stop":
+                        ui.println(taskManager.stop(arg ?? ""));
+                        break;
+                    case "compact":
+                        ui.startSpinner("compacting");
+                        try {
+                            await agent.compactNow();
+                        }
+                        catch (err) {
+                            ui.error(String(err?.message ?? err));
+                        }
+                        finally {
+                            ui.stopSpinner();
+                        }
+                        break;
+                    case "context":
+                        const budget = agent.contextBudget();
+                        ui.status(`Context ${budget.prompt.toLocaleString()} / ${budget.window.toLocaleString()} tokens (${budget.source})\nReply reserve ${budget.reserve.toLocaleString()} · available ${budget.available.toLocaleString()} · ${agent.messages.length} messages · ${agent.tools.length} tools`);
+                        break;
+                    case "clear":
+                        agent.resetTranscript();
+                        toolCtx.plan.reset();
+                        ui.status("· conversation cleared");
+                        break;
+                    default:
+                        ui.warn(`Unknown command /${cmd} — try /help`);
+                }
+                ui.refresh();
+                continue;
+            }
+            try {
+                await agent.runTurn(input, attachments);
+                this.onTurnDone?.();
+            }
+            catch (err) {
+                ui.error(`\n${err?.message ?? err}`);
+                if (String(err?.message ?? "").toLowerCase().includes("does not support tools")) {
+                    ui.warn("This model does not support tool calling. Pick a tool-capable model with /models (e.g. qwen3, llama3.1, mistral-nemo).");
+                }
+            }
+        }
+    }
+    /** Idempotent: end-of-session hook, kill background tasks, close the UI,
+     * then tell the host. */
+    async shutdown() {
+        if (this.ended)
+            return;
+        this.ended = true;
+        this.agent.cancel();
+        try {
+            await this.bus.emit("session_end");
+        }
+        catch {
+            /* best effort */
+        }
+        this.taskManager.killAll();
+        this.ui.close();
+        this.onExit?.();
+    }
+    async switchModel() {
+        const { ui, agent } = this;
+        let fresh;
+        let idx;
+        // The picker is also where other machines are added and managed; after
+        // either, look again and reopen it so their models are right there.
+        for (;;) {
+            const hosts = (0, config_1.loadConfig)().hosts ?? [];
+            ui.startSpinner("looking for models");
+            fresh = await (0, detect_1.detectAll)({ hosts });
+            ui.stopSpinner();
+            if (!fresh.length)
+                ui.warn("No model server is answering right now.");
+            const rows = [...modelOptions(fresh, this.chosen), exports.FIND_ROW, ...(hosts.length ? [exports.HOSTS_ROW] : [])];
+            idx = await ui.select("Select model", rows);
+            if (idx === null)
+                return;
+            if (idx < fresh.length)
+                break;
+            if (rows[idx] === exports.FIND_ROW)
+                await (0, network_1.findModelsOnNetwork)(ui);
+            else
+                await (0, network_1.manageHosts)(ui);
+        }
+        let next;
+        ui.startSpinner(`loading ${fresh[idx].id}`);
+        try {
+            next = await (0, detect_1.resolveContextWindow)(fresh[idx], this.prefs.ctx);
+        }
+        catch (err) {
+            ui.error(String(err?.message ?? err));
+            return;
+        }
+        finally {
+            ui.stopSpinner();
+        }
+        this.chosen = next;
+        const p = makeProvider(next);
+        p.setEffort(this.effort);
+        agent.setProvider(p);
+        this.ctxMgr.setWindow(next.contextWindow, p.maxOutputTokens);
+        this.persist();
+        ui.println(sessionLine(next, agent.mode));
+        if (next.note)
+            ui.warn(`  ${next.note}`);
+        const advice = effortAdvice(next, this.effort);
+        if (advice)
+            ui.warn(`  ${advice}`);
+    }
+    async setMode(arg) {
+        const { ui, agent } = this;
+        let next = arg === "ro"
+            ? "ro"
+            : arg === "edit" || arg === "write"
+                ? "edit"
+                : arg === "bypass" || arg === "yolo"
+                    ? "bypass"
+                    : undefined;
+        if (!next) {
+            const idx = await ui.select("Select mode", [
+                { label: "read-only", hint: "read and search files only", current: agent.mode === "ro" },
+                {
+                    label: "edit",
+                    hint: "edit files; run commands inside the workspace, ask y/n for anything outside it",
+                    current: agent.mode === "edit",
+                },
+                {
+                    label: "bypass permissions",
+                    hint: "full access, never asks for approval",
+                    current: agent.mode === "bypass",
+                },
+            ]);
+            if (idx === null)
+                return;
+            next = exports.MODE_ORDER[idx];
+        }
+        agent.setMode(next, this.sysPrompt(next));
+        this.persist();
+    }
+    async setEffort(arg) {
+        const { ui, agent } = this;
+        const levels = ["default", "off", "low", "medium", "high"];
+        let next;
+        if (arg && levels.includes(arg)) {
+            next = arg === "default" ? null : arg;
+        }
+        else {
+            const idx = await ui.select("Reasoning effort", [
+                {
+                    label: "default",
+                    hint: this.chosen.reasoning?.default
+                        ? `the model's own default (${this.chosen.reasoning.default})`
+                        : "leave it to the model",
+                    current: this.effort === null,
+                },
+                { label: "off", hint: "no thinking — fastest, best for long tool loops", current: this.effort === "off" },
+                { label: "low", hint: "brief reasoning", current: this.effort === "low" },
+                { label: "medium", hint: "", current: this.effort === "medium" },
+                { label: "high", hint: "most thorough — slow on local models", current: this.effort === "high" },
+            ]);
+            if (idx === null)
+                return;
+            next = idx === 0 ? null : levels[idx];
+        }
+        this.effort = next;
+        agent.provider.setEffort(this.effort);
+        this.persist();
+        const label = agent.provider.effortLabel();
+        ui.status(`· effort ${label ?? this.effort ?? "default"}`);
+        const advice = effortAdvice(this.chosen, this.effort);
+        if (advice)
+            ui.warn(`  ${advice}`);
+    }
+}
+exports.Session = Session;