@sean.holung/minicode 0.3.5 → 0.3.7

package/dist/src/agent/home-env.js

@@ -0,0 +1,74 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import dotenv from "dotenv";
+import { MINICODE_HOME } from "./config.js";
+export function getHomeEnvPath(minicodeHome = MINICODE_HOME) {
+    return path.join(minicodeHome, ".env");
+}
+export async function loadHomeEnvValues(minicodeHome = MINICODE_HOME) {
+    const envPath = getHomeEnvPath(minicodeHome);
+    try {
+        const existing = await readFile(envPath, "utf8");
+        return dotenv.parse(existing);
+    }
+    catch {
+        return {};
+    }
+}
+function formatEnvValue(value) {
+    return value;
+}
+export async function upsertHomeEnvValues(options) {
+    const minicodeHome = options.minicodeHome ?? MINICODE_HOME;
+    const envPath = getHomeEnvPath(minicodeHome);
+    await mkdir(path.dirname(envPath), { recursive: true });
+    let existing = "";
+    try {
+        existing = await readFile(envPath, "utf8");
+    }
+    catch {
+        existing = "";
+    }
+    const pending = new Map(Object.entries(options.values));
+    const managedKeys = new Set(pending.keys());
+    const assignmentPattern = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=/;
+    const normalizedLines = existing === ""
+        ? []
+        : existing.split(/\r?\n/);
+    const nextLines = [];
+    const seen = new Set();
+    for (const line of normalizedLines) {
+        const match = line.match(assignmentPattern);
+        if (!match) {
+            nextLines.push(line);
+            continue;
+        }
+        const key = match[1];
+        if (!managedKeys.has(key)) {
+            nextLines.push(line);
+            continue;
+        }
+        if (seen.has(key)) {
+            continue;
+        }
+        const nextValue = pending.get(key);
+        if (nextValue !== null) {
+            nextLines.push(`${key}=${formatEnvValue(nextValue)}`);
+        }
+        seen.add(key);
+        pending.delete(key);
+    }
+    const pendingEntries = [...pending.entries()].filter((entry) => entry[1] !== null);
+    if (pendingEntries.length > 0 && nextLines.length > 0 && nextLines[nextLines.length - 1] !== "") {
+        nextLines.push("");
+    }
+    for (const [key, value] of pendingEntries) {
+        nextLines.push(`${key}=${formatEnvValue(value)}`);
+    }
+    const fileContent = `${nextLines.join("\n").replace(/\n+$/, "")}\n`;
+    await writeFile(envPath, fileContent, "utf8");
+    return {
+        path: envPath,
+        updatedKeys: Object.keys(options.values),
+    };
+}

package/dist/src/cli/config-slash-command.js

@@ -1,5 +1,5 @@
 import { formatConfigForDisplay, MINICODE_HOME, resolveConfigEnv } from "../agent/config.js";
-import { formatPersistedConfigValue, getEditableConfigDefinition, getEffectiveEditableConfigValue, isEditableConfigKey, listEditableConfigDefinitions, loadPersistedConfig, setPersistedConfigValue, unsetPersistedConfigValue, } from "../agent/editable-config.js";
+import { buildStructuredConfigPayload, formatPersistedConfigValue, getEditableConfigDefinition, getEffectiveEditableConfigValue, isEditableConfigKey, listEditableConfigDefinitions, setPersistedConfigValue, unsetPersistedConfigValue, } from "../agent/editable-config.js";
 function renderUsage() {
     return [
         'Usage:',
@@ -12,7 +12,7 @@ function renderUsage() {
 }
 function renderEditableKeys() {
     const lines = [
-        "Editable config keys (persisted in ~/.minicode/agent.config.json; environment variables take precedence):",
+        "Editable config keys (persisted in ~/.minicode/.env; exported shell environment variables take precedence):",
     ];
     for (const definition of listEditableConfigDefinitions()) {
         const valueHint = definition.type === "enum"
@@ -21,7 +21,7 @@ function renderEditableKeys() {
         lines.push(`  ${definition.key} ${valueHint} — ${definition.description} (env: ${definition.envVar})`);
     }
     lines.push("");
-    lines.push('Use "/config set <key> <value>" to update your global config.');
+    lines.push('Use "/config set <key> <value>" to update ~/.minicode/.env.');
     lines.push("Secrets like API keys stay env-only for now.");
     return lines.join("\n");
 }
@@ -31,14 +31,16 @@ async function renderConfigValue(key, context) {
     }
     const minicodeHome = context.minicodeHome ?? MINICODE_HOME;
     const definition = getEditableConfigDefinition(key);
-    const persisted = await loadPersistedConfig(minicodeHome);
-    const env = await resolveConfigEnv({ minicodeHome });
-    const envValue = env.values[definition.envVar];
+    const payload = await buildStructuredConfigPayload(context.config, minicodeHome);
+    const entry = payload.entries.find((item) => item.key === key);
+    if (!entry) {
+        return `Unknown editable config key "${key}".\n\n${renderEditableKeys()}`;
+    }
     return [
         `${definition.key}`,
         `  effective: ${getEffectiveEditableConfigValue(context.config, key)}`,
-        `  config file: ${formatPersistedConfigValue(persisted[definition.fileKey])}`,
-        `  env override (${definition.envVar}): ${formatPersistedConfigValue(envValue)}`,
+        `  saved in ~/.minicode/.env: ${formatPersistedConfigValue(entry.persistedValue)}`,
+        `  exported env override (${definition.envVar}): ${formatPersistedConfigValue(entry.envValue)}`,
     ].join("\n");
 }
 async function persistConfigValue(key, rawValue, context) {
@@ -59,8 +61,8 @@ async function persistConfigValue(key, rawValue, context) {
             `File: ${result.path}`,
             "Restart minicode to pick up persisted config changes in a new session.",
         ];
-        if (env.values[definition.envVar] !== undefined) {
-            lines.push(`Note: ${definition.envVar} is currently set and will override this persisted value until it is unset.`);
+        if (env.sources[definition.envVar] === "process") {
+            lines.push(`Note: ${definition.envVar} is currently exported in your shell and will override this saved value until it is unset.`);
         }
         return lines.join("\n");
     }
@@ -82,11 +84,11 @@ async function removeConfigValue(key, context) {
     });
     const lines = [
         `Removed persisted value for "${key}".`,
-        `File: ${minicodeHome}/agent.config.json`,
+        `File: ${minicodeHome}/.env`,
         "Restart minicode to ensure the updated config is applied in a new session.",
     ];
-    if (env.values[definition.envVar] !== undefined) {
-        lines.push(`Note: ${definition.envVar} is still set in the environment, so the effective value may remain unchanged.`);
+    if (env.sources[definition.envVar] === "process") {
+        lines.push(`Note: ${definition.envVar} is still exported in your shell, so the effective value may remain unchanged.`);
     }
     return lines.join("\n");
 }

package/dist/src/serve/agent-bridge.js

@@ -13,9 +13,11 @@ import { getSymbolDisplayName } from "../indexer/symbol-names.js";
 export class AgentBridge {
     agent;
     config;
+    baseConfig;
     modelClient;
     projectIndex;
-    buildAgent;
+    toolRegistry;
+    sessionOpenRouterConnected = false;
     busy = false;
     abortController = null;
     broadcast;
@@ -43,9 +45,8 @@ export class AgentBridge {
     }
     async init() {
         const config = await loadAgentConfig();
-        let modelClient;
         try {
-            modelClient = createModelClient(config);
+            this.modelClient = createModelClient(config);
         }
         catch {
             // Model client may fail to initialize if API keys are missing.
@@ -75,28 +76,47 @@ export class AgentBridge {
             return this.appendAnnotationsToResult(name, input, result);
         };
         this.config = config;
+        this.baseConfig = AgentBridge.cloneConfig(config);
         this.projectIndex = projectIndex;
-        if (modelClient) {
-            this.modelClient = modelClient;
-            this.buildAgent = (session, onUiUpdate) => {
-                return new CodingAgent({
-                    config,
-                    modelClient,
-                    toolRegistry,
-                    verbose: this.verbose,
-                    ...(session ? { session } : {}),
-                    ...(projectIndex !== undefined
-                        ? { getCodeMap: (focusSymbols) => projectIndex.getCodeMap(undefined, focusSymbols) }
-                        : {}),
-                    onUiUpdate: onUiUpdate ?? ((event) => {
-                        this.emit(event);
-                    }),
-                    getSystemPromptSuffix: () => this.buildAnnotationSuffix(),
-                });
-            };
-            this.agent = this.buildAgent();
+        this.toolRegistry = toolRegistry;
+        if (this.modelClient) {
+            this.agent = this.createAgent();
         }
     }
+    static cloneConfig(config) {
+        return {
+            ...config,
+            commandDenylist: [...config.commandDenylist],
+        };
+    }
+    static applyConfig(target, source) {
+        const targetRecord = target;
+        for (const key of Object.keys(targetRecord)) {
+            if (!(key in source)) {
+                delete targetRecord[key];
+            }
+        }
+        Object.assign(targetRecord, AgentBridge.cloneConfig(source));
+    }
+    createAgent(session, onUiUpdate) {
+        if (!this.modelClient || !this.toolRegistry) {
+            throw new Error("Agent runtime is not initialized.");
+        }
+        return new CodingAgent({
+            config: this.config,
+            modelClient: this.modelClient,
+            toolRegistry: this.toolRegistry,
+            verbose: this.verbose,
+            ...(session ? { session } : {}),
+            ...(this.projectIndex !== undefined
+                ? { getCodeMap: (focusSymbols) => this.projectIndex.getCodeMap(undefined, focusSymbols) }
+                : {}),
+            onUiUpdate: onUiUpdate ?? ((event) => {
+                this.emit(event);
+            }),
+            getSystemPromptSuffix: () => this.buildAnnotationSuffix(),
+        });
+    }
     // ── File watcher for automatic reindexing ──
     static WATCH_EXTENSIONS = new Set([".ts", ".tsx", ".js", ".jsx"]);
     static SKIP_DIRS = new Set(["node_modules", ".git", "dist", "build", "coverage"]);
@@ -171,6 +191,45 @@ export class AgentBridge {
     getConfig() {
         return this.config;
     }
+    isOpenRouterSessionConnected() {
+        return this.sessionOpenRouterConnected;
+    }
+    connectOpenRouter(apiKey) {
+        const trimmedKey = apiKey.trim();
+        if (!trimmedKey) {
+            throw new Error("OpenRouter OAuth exchange did not return an API key.");
+        }
+        if (this.busy) {
+            throw new Error("busy");
+        }
+        const currentSession = this.agent?.getSession();
+        this.config.modelProvider = "openai-compatible";
+        this.config.openAiBaseUrl = "https://openrouter.ai/api/v1";
+        this.config.openAiApiKey = trimmedKey;
+        this.sessionOpenRouterConnected = true;
+        this.modelClient = createModelClient(this.config);
+        this.agent = this.createAgent(currentSession);
+    }
+    disconnectOpenRouter() {
+        if (this.busy) {
+            throw new Error("busy");
+        }
+        if (!this.sessionOpenRouterConnected) {
+            return false;
+        }
+        const currentSession = this.agent?.getSession();
+        AgentBridge.applyConfig(this.config, this.baseConfig);
+        this.sessionOpenRouterConnected = false;
+        try {
+            this.modelClient = createModelClient(this.config);
+            this.agent = this.createAgent(currentSession);
+        }
+        catch {
+            this.modelClient = undefined;
+            this.agent = undefined;
+        }
+        return true;
+    }
     requireAgent() {
         if (!this.agent) {
             throw new Error("Agent is not configured. Set MODEL and provider settings in ~/.minicode/.env");
@@ -230,13 +289,13 @@ export class AgentBridge {
         return saveSession(agent.getSession(), label, annotationsObj);
     }
     async loadSess(label) {
-        if (!this.buildAgent) {
+        if (!this.modelClient) {
             throw new Error("Agent is not configured.");
         }
         const result = (await loadSessionByLabel(label)) ?? (await loadSession(label));
         if (!result)
             return null;
-        this.agent = this.buildAgent(result.session);
+        this.agent = this.createAgent(result.session);
         // Restore annotations from saved session
         this.annotations.clear();
         if (result.annotations) {
@@ -473,12 +532,12 @@ export class AgentBridge {
     async explainSymbol(name, onEvent, signal) {
         if (!this.projectIndex)
             throw new Error("No project index");
-        if (!this.buildAgent)
+        if (!this.modelClient)
             throw new Error("Agent is not configured.");
         const sym = this.projectIndex.getSymbol(name);
         if (!sym)
             throw new Error(`Symbol "${name}" not found`);
-        const explainAgent = this.buildAgent(undefined, onEvent);
+        const explainAgent = this.createAgent(undefined, onEvent);
         const prompt = `Explain "${sym.name}" (${sym.kind} in ${sym.filePath}).
 Use read_symbol, get_dependencies, find_references to gather context.
 Explain what it does, how it works, what depends on it, and key design decisions.
@@ -491,12 +550,12 @@ Be concise but thorough.`;
         const report = this.getStructuralAnalysis();
         if (!report)
             throw new Error("No project index");
-        if (!this.buildAgent)
+        if (!this.modelClient)
             throw new Error("Agent is not configured.");
         const finding = report.findings.find((item) => item.id === findingId);
         if (!finding)
             throw new Error(`Structural finding "${findingId}" not found`);
-        const explainAgent = this.buildAgent(undefined, onEvent);
+        const explainAgent = this.createAgent(undefined, onEvent);
         const affectedSymbols = finding.symbols.length > 0
             ? finding.symbols.slice(0, 8).join(", ")
             : "(none)";

package/dist/src/serve/mcp-server.js

@@ -11,6 +11,7 @@ import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/
 import { z } from "zod";
 import { getSymbolDisplayName } from "../indexer/symbol-names.js";
 import { formatAmbiguousSymbolMatches, resolveSymbolInput, } from "../shared/symbol-resolution.js";
+import { searchSymbols } from "../shared/symbol-search.js";
 /** Active transports keyed by session ID. */
 const transports = new Map();
 /**
@@ -157,22 +158,27 @@ function createMcpServer(bridge, emit) {
         kind: z.string().optional().describe("Filter by kind: function, class, interface, type, variable, method"),
     }, async ({ query, kind }) => {
         return wrapToolCall("search_code_map", { query, kind }, async () => {
-            const symbols = bridge.getSymbols();
-            const queryLower = query.toLowerCase();
-            let matches = symbols.filter((s) => {
-                const nameMatch = s.name.toLowerCase().includes(queryLower) ||
-                    s.qualifiedName.toLowerCase().includes(queryLower);
-                return nameMatch;
-            });
-            if (kind) {
-                matches = matches.filter((s) => s.kind === kind);
-            }
-            matches = matches.slice(0, 30);
-            if (matches.length === 0) {
+            const result = searchSymbols(bridge.getSymbols().map((symbol) => ({
+                symbol,
+                record: {
+                    name: symbol.name,
+                    qualifiedName: symbol.qualifiedName,
+                    kind: symbol.kind,
+                    filePath: symbol.filePath,
+                    startLine: symbol.startLine,
+                    exported: symbol.exported,
+                },
+                lookupNames: [symbol.name, symbol.qualifiedName],
+            })), query, { kind, limit: 30 });
+            if (result.total === 0) {
                 return { content: [{ type: "text", text: `No symbols matching "${query}"${kind ? ` (kind: ${kind})` : ""}.` }] };
             }
+            const matches = result.matches;
+            const heading = result.mode === "similar"
+                ? `No exact substring matches for "${query}"${kind ? ` (kind: ${kind})` : ""}. Showing ${matches.length} similar symbol(s):`
+                : `Found ${matches.length} symbol(s) matching "${query}":`;
             const lines = [
-                `Found ${matches.length} symbol(s) matching "${query}":`,
+                heading,
                 ...matches.map((s) => `  - ${s.name} (${s.kind}) — ${s.filePath}:${s.startLine} — qualified: ${s.qualifiedName}${s.signature ? `\n    ${s.signature}` : ""}`),
             ];
             return { content: [{ type: "text", text: lines.join("\n") }] };

package/dist/src/serve/server.js

@@ -8,9 +8,11 @@ import { createWebSocketServer } from "./websocket.js";
 import { handleChatCompletions, handleModels } from "./openai-compat.js";
 import { formatConfigForDisplay, getConfigMissing } from "../agent/config.js";
 import { applyPersistedConfigUpdates, buildStructuredConfigPayload } from "../agent/editable-config.js";
+import { getHomeEnvPath, upsertHomeEnvValues } from "../agent/home-env.js";
 import { sortModelsAlphabetically } from "../model-utils.js";
 import { serializeSymbolMatch } from "../shared/symbol-resolution.js";
 import { handleMcpRequest } from "./mcp-server.js";
+import { buildSessionPreview } from "../session/session-preview.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 // Resolve web dir: always serve from dist/src/web (built by scripts/build-web.mjs)
 // In dev (tsx): __dirname = src/serve → go up to project root, then dist/src/web
@@ -28,6 +30,19 @@ function sendJson(res, status, body) {
     res.writeHead(status, { "Content-Type": "application/json" });
     res.end(JSON.stringify(body));
 }
+function resolveWorkspaceFilePath(workspaceRoot, requestedPath) {
+    const trimmedPath = requestedPath.trim();
+    if (trimmedPath.length === 0) {
+        return null;
+    }
+    const root = path.resolve(workspaceRoot);
+    const absolutePath = path.resolve(root, trimmedPath);
+    const relativePath = path.relative(root, absolutePath);
+    if (relativePath.startsWith("..") || path.isAbsolute(relativePath)) {
+        return null;
+    }
+    return { absolutePath, relativePath };
+}
 function readBody(req) {
     return new Promise((resolve, reject) => {
         const chunks = [];
@@ -49,7 +64,12 @@ async function serveStatic(res, urlPath) {
         const content = await readFile(filePath);
         const ext = path.extname(filePath);
         const contentType = MIME_TYPES[ext] ?? "application/octet-stream";
-        res.writeHead(200, { "Content-Type": contentType });
+        res.writeHead(200, {
+            "Content-Type": contentType,
+            // This local UI changes often during development. Avoid stale browser bundles
+            // causing the app to run an older client against a newer server.
+            "Cache-Control": "no-store",
+        });
         res.end(content);
     }
     catch {
@@ -62,7 +82,6 @@ async function buildWebSettingsPayload(config, minicodeHome) {
 }
 /** Create the HTTP request handler. Exported for testing. */
 export function createRequestHandler(bridge, emit, options = {}) {
-    const config = bridge.getConfig();
     const emitFn = emit ?? (() => { });
     const minicodeHome = options.minicodeHome;
     return (req, res) => {
@@ -70,6 +89,7 @@ export function createRequestHandler(bridge, emit, options = {}) {
         const method = req.method ?? "GET";
         const pathname = url.pathname;
         const handle = async () => {
+            const config = bridge.getConfig();
             // MCP (Model Context Protocol) endpoint
             if (pathname === "/mcp") {
                 await handleMcpRequest(req, res, bridge, emitFn);
@@ -92,6 +112,8 @@ export function createRequestHandler(bridge, emit, options = {}) {
                     workspace: config.workspaceRoot,
                     model: config.model,
                     provider: config.modelProvider,
+                    baseUrl: config.openAiBaseUrl,
+                    sessionOpenRouterConnected: bridge.isOpenRouterSessionConnected(),
                     needsSetup: missing.length > 0,
                     missing,
                 });
@@ -102,6 +124,132 @@ export function createRequestHandler(bridge, emit, options = {}) {
                 sendJson(res, 200, { models, activeModel: config.model });
                 return;
             }
+            if (pathname === "/api/openrouter/connect" && method === "POST") {
+                const body = JSON.parse(await readBody(req));
+                if (!body.code || typeof body.code !== "string") {
+                    sendJson(res, 400, { error: "code is required" });
+                    return;
+                }
+                if (!body.codeVerifier || typeof body.codeVerifier !== "string") {
+                    sendJson(res, 400, { error: "codeVerifier is required" });
+                    return;
+                }
+                let exchangeResponse;
+                try {
+                    exchangeResponse = await fetch("https://openrouter.ai/api/v1/auth/keys", {
+                        method: "POST",
+                        headers: {
+                            "Content-Type": "application/json",
+                        },
+                        body: JSON.stringify({
+                            code: body.code,
+                            code_verifier: body.codeVerifier,
+                            code_challenge_method: "S256",
+                        }),
+                    });
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : "OpenRouter OAuth exchange failed";
+                    sendJson(res, 502, { error: message });
+                    return;
+                }
+                if (!exchangeResponse.ok) {
+                    const message = await exchangeResponse.text();
+                    sendJson(res, exchangeResponse.status, {
+                        error: message.trim().length > 0
+                            ? `OpenRouter OAuth exchange failed: ${message}`
+                            : `OpenRouter OAuth exchange failed (${exchangeResponse.status})`,
+                    });
+                    return;
+                }
+                const payload = await exchangeResponse.json();
+                if (!payload.key || typeof payload.key !== "string") {
+                    sendJson(res, 502, { error: "OpenRouter OAuth exchange did not return an API key." });
+                    return;
+                }
+                try {
+                    bridge.connectOpenRouter(payload.key);
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : "Failed to configure OpenRouter";
+                    sendJson(res, message === "busy" ? 409 : 400, { error: message });
+                    return;
+                }
+                let persistedToEnv = false;
+                let persistedEnvPath = null;
+                let persistWarning = null;
+                if (body.persistToEnv === true) {
+                    try {
+                        const result = await upsertHomeEnvValues({
+                            values: {
+                                MODEL_PROVIDER: "openai-compatible",
+                                OPENAI_BASE_URL: "https://openrouter.ai/api/v1",
+                                OPENROUTER_API_KEY: payload.key,
+                            },
+                            ...(minicodeHome ? { minicodeHome } : {}),
+                        });
+                        persistedToEnv = true;
+                        persistedEnvPath = result.path;
+                    }
+                    catch (error) {
+                        const message = error instanceof Error ? error.message : "Failed to update ~/.minicode/.env";
+                        persistedEnvPath = getHomeEnvPath(minicodeHome);
+                        persistWarning = `OpenRouter connected for this serve session, but minicode could not update ${persistedEnvPath}: ${message}`;
+                    }
+                }
+                const missing = getConfigMissing(config);
+                const onlyModelMissing = missing.length === 1 && missing[0] === "MODEL is not set";
+                const message = persistWarning
+                    ? `${persistWarning}${onlyModelMissing ? " Select a model to continue." : ""}`
+                    : persistedToEnv
+                        ? (onlyModelMissing
+                            ? "OpenRouter connected for this serve session and saved to ~/.minicode/.env. Select a model to continue, and minicode will remember it for future runs."
+                            : "OpenRouter connected for this serve session and saved to ~/.minicode/.env for future runs.")
+                        : (onlyModelMissing
+                            ? "OpenRouter connected for this serve session. Select a model to continue."
+                            : "OpenRouter connected for this serve session.");
+                sendJson(res, 200, {
+                    ok: true,
+                    sessionOnly: true,
+                    persistedToEnv,
+                    persistedEnvPath,
+                    persistWarning,
+                    provider: config.modelProvider,
+                    model: config.model,
+                    baseUrl: config.openAiBaseUrl,
+                    needsSetup: missing.length > 0,
+                    missing,
+                    message,
+                });
+                return;
+            }
+            if (pathname === "/api/openrouter/disconnect" && method === "POST") {
+                let disconnected = false;
+                try {
+                    disconnected = bridge.disconnectOpenRouter();
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : "Failed to remove OpenRouter session";
+                    sendJson(res, message === "busy" ? 409 : 400, { error: message });
+                    return;
+                }
+                const missing = getConfigMissing(config);
+                const body = {
+                    ok: true,
+                    disconnected,
+                    sessionOnly: true,
+                    provider: config.modelProvider,
+                    model: config.model,
+                    baseUrl: config.openAiBaseUrl,
+                    needsSetup: missing.length > 0,
+                    missing,
+                    message: disconnected
+                        ? "Removed the session-only OpenRouter connection and restored your original provider settings."
+                        : "No session-only OpenRouter connection was active.",
+                };
+                sendJson(res, 200, body);
+                return;
+            }
             if (pathname === "/api/model" && method === "POST") {
                 const body = JSON.parse(await readBody(req));
                 if (!body.model || typeof body.model !== "string") {
@@ -109,7 +257,26 @@ export function createRequestHandler(bridge, emit, options = {}) {
                     return;
                 }
                 bridge.switchModel(body.model);
-                sendJson(res, 200, { model: body.model });
+                let persistedToEnv = false;
+                let persistedEnvPath = null;
+                let message;
+                try {
+                    const result = await upsertHomeEnvValues({
+                        values: {
+                            MODEL: body.model,
+                        },
+                        ...(minicodeHome ? { minicodeHome } : {}),
+                    });
+                    persistedToEnv = true;
+                    persistedEnvPath = result.path;
+                    message = `Saved MODEL=${body.model} to ~/.minicode/.env.`;
+                }
+                catch (error) {
+                    const persistMessage = error instanceof Error ? error.message : "Failed to update ~/.minicode/.env";
+                    sendJson(res, 500, { error: persistMessage });
+                    return;
+                }
+                sendJson(res, 200, { model: body.model, persistedToEnv, persistedEnvPath, message });
                 return;
             }
             if (pathname === "/api/context" && method === "GET") {
@@ -180,7 +347,10 @@ export function createRequestHandler(bridge, emit, options = {}) {
                     sendJson(res, 404, { error: "Session not found" });
                     return;
                 }
-                sendJson(res, 200, { label: result.label });
+                sendJson(res, 200, {
+                    label: result.label,
+                    messages: buildSessionPreview(result.session.getMessages()),
+                });
                 return;
             }
             // ── Graph / Index API ──
@@ -266,6 +436,22 @@ export function createRequestHandler(bridge, emit, options = {}) {
                 }
                 return;
             }
+            if (pathname === "/api/file-source" && method === "GET") {
+                const requestedPath = url.searchParams.get("path") ?? "";
+                const resolved = resolveWorkspaceFilePath(config.workspaceRoot, requestedPath);
+                if (!resolved) {
+                    sendJson(res, 403, { error: "Invalid workspace file path" });
+                    return;
+                }
+                try {
+                    const source = await readFile(resolved.absolutePath, "utf8");
+                    sendJson(res, 200, { filePath: resolved.relativePath, source });
+                }
+                catch {
+                    sendJson(res, 404, { error: `Could not read file: ${resolved.relativePath}` });
+                }
+                return;
+            }
             if (pathname === "/api/code-map" && method === "GET") {
                 const budgetParam = url.searchParams.get("budget");
                 const budget = budgetParam ? Number(budgetParam) : undefined;

package/dist/src/session/session-preview.js

@@ -0,0 +1,14 @@
+export const DEFAULT_SESSION_PREVIEW_LIMIT = 10;
+const COMPACTION_SUMMARY_PREFIX = "[Conversation Summary";
+export function isCompactionSummaryMessage(message) {
+    return (message.role === "user" &&
+        message.content.startsWith(COMPACTION_SUMMARY_PREFIX));
+}
+export function buildSessionPreview(messages, limit = DEFAULT_SESSION_PREVIEW_LIMIT) {
+    if (limit <= 0) {
+        return [];
+    }
+    return messages
+        .filter((message) => !isCompactionSummaryMessage(message))
+        .slice(-limit);
+}