@sean.holung/minicode 0.3.6 → 0.3.8

package/README.md

@@ -1,6 +1,6 @@
 # minicode
 
-> Now supports connecting to [OpenRouter](https://openrouter.ai/) account via minicode UI. Sign in with OpenRouter account. Use for free with compatible free tier OpenRouter hosted models from MiniMax, Nvidia, Qwen, Google, etc.
+> Now supports connecting to [OpenRouter](https://openrouter.ai/) account via minicode UI. Sign in with OpenRouter account. Use for free with compatible [free tier OpenRouter hosted models](https://openrouter.ai/models?q=free) from MiniMax, Nvidia, Qwen, Google, etc.
 
 A graph-native coding agent and code exploration environment built around structural context optimization that leverages symbol-aware retrieval, dependency graphs, and targeted context. It started as a way to make local models viable under tighter context budgets, and it now also works well with hosted frontier models through the same runtime, web UI, and OpenAI-compatible serve mode. 
 
@@ -199,6 +199,7 @@ Nothing is written inside your workspace; config and cache live under `~/.minico
 | `COMMAND_DENYLIST`      | No              | none                       | Optional JSON array or comma-separated regex patterns appended to the built-in destructive-command denylist                         |
 | `MAX_STEPS`             | No              | `50`                       | Max agent loop iterations per user turn                                                                                               |
 | `MAX_TOKENS`            | No              | `4096`                     | Max model output tokens per model call                                                                                                |
+| `MODEL_TIMEOUT_SECONDS` | No              | `60`                       | Timeout waiting for a model API call to start responding before aborting and surfacing an error                                       |
 | `MAX_CONTEXT_TOKENS`    | No              | `32000`                    | Approximate session history trimming target. For small models (e.g. 8k context), set lower (e.g. `6000`) to leave room for responses. |
 | `MAX_TOOL_OUTPUT_CHARS` | No              | `8000`                     | Max chars per tool result before truncation. Set to `0` to disable.                                                                   |
 | `WORKSPACE_ROOT`        | No              | current working directory  | Root directory tools are allowed to access (set at runtime, not typically configured)                                                  |

package/dist/scripts/run-benchmarks.js

@@ -99,6 +99,7 @@ export function buildConfig(options = {}) {
         model,
         maxSteps: getNumberSetting(getShellOverride("MAX_STEPS"), fileConfig.maxSteps, 50),
         maxTokens: getNumberSetting(getShellOverride("MAX_TOKENS"), fileConfig.maxTokens, 4096),
+        modelTimeoutSeconds: getNumberSetting(getShellOverride("MODEL_TIMEOUT_SECONDS"), fileConfig.modelTimeoutSeconds, 60),
         maxContextTokens: getNumberSetting(getShellOverride("MAX_CONTEXT_TOKENS"), fileConfig.maxContextTokens, 32000),
         workspaceRoot: repoRoot,
         commandTimeoutMs: getNumberSetting(getShellOverride("COMMAND_TIMEOUT_MS"), fileConfig.commandTimeoutMs, 30000),

package/dist/src/agent/config.js

@@ -16,6 +16,7 @@ export function formatConfigForDisplay(config) {
         "model: " + config.model,
         "maxSteps: " + config.maxSteps,
         "maxTokens: " + config.maxTokens,
+        "modelTimeoutSeconds: " + config.modelTimeoutSeconds,
         "maxContextTokens: " + config.maxContextTokens,
         "commandTimeoutMs: " + config.commandTimeoutMs,
         "maxFileSizeBytes: " + config.maxFileSizeBytes,
@@ -59,6 +60,31 @@ export function getConfigMissing(config) {
     }
     return missing;
 }
+function hasExplicitConfigValue(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function parseExplicitModelProvider(value) {
+    if (!hasExplicitConfigValue(value)) {
+        return undefined;
+    }
+    return parseModelProvider(value);
+}
+export function getConfiguredProvider(config, env = process.env) {
+    const explicitModelProvider = parseExplicitModelProvider(env.MODEL_PROVIDER);
+    if (config.modelProvider === "anthropic") {
+        return explicitModelProvider === "anthropic" || hasExplicitConfigValue(env.ANTHROPIC_API_KEY)
+            ? "anthropic"
+            : null;
+    }
+    const hasExplicitOpenAiCompatibleConfig = explicitModelProvider === "openai-compatible" ||
+        hasExplicitConfigValue(env.OPENAI_BASE_URL) ||
+        hasExplicitConfigValue(env.OPENROUTER_API_KEY);
+    if (!hasExplicitOpenAiCompatibleConfig) {
+        return null;
+    }
+    const baseUrl = (env.OPENAI_BASE_URL ?? config.openAiBaseUrl).trim().toLowerCase();
+    return baseUrl.includes("openrouter") ? "openrouter" : "openai-compatible";
+}
 export function getConfigSetupMessage(config) {
     const missing = getConfigMissing(config);
     if (missing.length === 0) {
@@ -230,6 +256,7 @@ export async function loadAgentConfig(cwd = process.cwd(), options = {}) {
         model: env.MODEL ?? "",
         maxSteps: parseNumber(env.MAX_STEPS, 50),
         maxTokens: parseNumber(env.MAX_TOKENS, 4096),
+        modelTimeoutSeconds: parseNumber(env.MODEL_TIMEOUT_SECONDS, 60),
         maxContextTokens: parseNumber(env.MAX_CONTEXT_TOKENS, 32_000),
         workspaceRoot,
         commandTimeoutMs: parseNumber(env.COMMAND_TIMEOUT_MS, 30_000),

package/dist/src/agent/editable-config.js

@@ -34,6 +34,12 @@ export const EDITABLE_CONFIG_DEFINITIONS = [
         type: "number",
         description: "Maximum completion tokens per model response",
     },
+    {
+        key: "modelTimeoutSeconds",
+        envVar: "MODEL_TIMEOUT_SECONDS",
+        type: "number",
+        description: "Maximum time to wait for a model API call to start responding",
+    },
     {
         key: "maxContextTokens",
         envVar: "MAX_CONTEXT_TOKENS",

package/dist/src/model-utils.js

@@ -1,4 +1,4 @@
-function getModelDisplayName(model) {
+export function getModelDisplayName(model) {
     return (model.name ?? model.id).trim();
 }
 export function sortModelsAlphabetically(models) {
@@ -16,3 +16,20 @@ export function sortModelsAlphabetically(models) {
         });
     });
 }
+function normalizeModelSearchValue(value) {
+    return value
+        .trim()
+        .toLocaleLowerCase()
+        .split(/\s+/)
+        .filter(Boolean);
+}
+export function filterModelsByQuery(models, query) {
+    const tokens = normalizeModelSearchValue(query);
+    if (tokens.length === 0) {
+        return [...models];
+    }
+    return models.filter((model) => {
+        const haystack = `${getModelDisplayName(model)} ${model.id}`.toLocaleLowerCase();
+        return tokens.every((token) => haystack.includes(token));
+    });
+}

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

@@ -17,7 +17,7 @@ export class AgentBridge {
     modelClient;
     projectIndex;
     toolRegistry;
-    sessionOpenRouterConnected = false;
+    sessionProviderConnection = null;
     busy = false;
     abortController = null;
     broadcast;
@@ -68,17 +68,10 @@ export class AgentBridge {
         catch {
             projectIndex = undefined;
         }
-        const toolRegistry = createToolRegistry(config, projectIndex);
-        // Wrap tool registry execute to inject annotations into tool results
-        const originalExecute = toolRegistry.execute.bind(toolRegistry);
-        toolRegistry.execute = async (name, input) => {
-            const result = await originalExecute(name, input);
-            return this.appendAnnotationsToResult(name, input, result);
-        };
         this.config = config;
         this.baseConfig = AgentBridge.cloneConfig(config);
         this.projectIndex = projectIndex;
-        this.toolRegistry = toolRegistry;
+        this.installToolRegistry(projectIndex);
         if (this.modelClient) {
             this.agent = this.createAgent();
         }
@@ -98,6 +91,16 @@ export class AgentBridge {
         }
         Object.assign(targetRecord, AgentBridge.cloneConfig(source));
     }
+    installToolRegistry(projectIndex) {
+        const toolRegistry = createToolRegistry(this.config, projectIndex);
+        // Wrap tool registry execute to inject annotations into tool results.
+        const originalExecute = toolRegistry.execute.bind(toolRegistry);
+        toolRegistry.execute = async (name, input) => {
+            const result = await originalExecute(name, input);
+            return this.appendAnnotationsToResult(name, input, result);
+        };
+        this.toolRegistry = toolRegistry;
+    }
     createAgent(session, onUiUpdate) {
         if (!this.modelClient || !this.toolRegistry) {
             throw new Error("Agent runtime is not initialized.");
@@ -179,7 +182,8 @@ export class AgentBridge {
             }
         }
         catch {
-            // File may have been deleted — ignore
+            // File may have been deleted or renamed. A workspace refresh prunes stale symbols.
+            await this.refreshIndex();
         }
     }
     isReady() {
@@ -192,7 +196,10 @@ export class AgentBridge {
         return this.config;
     }
     isOpenRouterSessionConnected() {
-        return this.sessionOpenRouterConnected;
+        return this.sessionProviderConnection === "openrouter";
+    }
+    isOpenAiCompatibleSessionConnected() {
+        return this.sessionProviderConnection === "openai-compatible";
     }
     connectOpenRouter(apiKey) {
         const trimmedKey = apiKey.trim();
@@ -206,7 +213,29 @@ export class AgentBridge {
         this.config.modelProvider = "openai-compatible";
         this.config.openAiBaseUrl = "https://openrouter.ai/api/v1";
         this.config.openAiApiKey = trimmedKey;
-        this.sessionOpenRouterConnected = true;
+        this.sessionProviderConnection = "openrouter";
+        this.modelClient = createModelClient(this.config);
+        this.agent = this.createAgent(currentSession);
+    }
+    connectOpenAiCompatible(baseUrl, apiKey) {
+        const trimmedBaseUrl = baseUrl.trim().replace(/\/+$/, "");
+        if (!trimmedBaseUrl) {
+            throw new Error("OpenAI-compatible endpoint is required.");
+        }
+        if (this.busy) {
+            throw new Error("busy");
+        }
+        const currentSession = this.agent?.getSession();
+        this.config.modelProvider = "openai-compatible";
+        this.config.openAiBaseUrl = trimmedBaseUrl;
+        const trimmedApiKey = apiKey?.trim() ?? "";
+        if (trimmedApiKey) {
+            this.config.openAiApiKey = trimmedApiKey;
+        }
+        else {
+            delete this.config.openAiApiKey;
+        }
+        this.sessionProviderConnection = "openai-compatible";
         this.modelClient = createModelClient(this.config);
         this.agent = this.createAgent(currentSession);
     }
@@ -214,12 +243,24 @@ export class AgentBridge {
         if (this.busy) {
             throw new Error("busy");
         }
-        if (!this.sessionOpenRouterConnected) {
+        if (this.sessionProviderConnection !== "openrouter") {
             return false;
         }
+        return this.disconnectSessionProvider();
+    }
+    disconnectOpenAiCompatible() {
+        if (this.busy) {
+            throw new Error("busy");
+        }
+        if (this.sessionProviderConnection !== "openai-compatible") {
+            return false;
+        }
+        return this.disconnectSessionProvider();
+    }
+    disconnectSessionProvider() {
         const currentSession = this.agent?.getSession();
         AgentBridge.applyConfig(this.config, this.baseConfig);
-        this.sessionOpenRouterConnected = false;
+        this.sessionProviderConnection = null;
         try {
             this.modelClient = createModelClient(this.config);
             this.agent = this.createAgent(currentSession);
@@ -312,6 +353,36 @@ export class AgentBridge {
     hasIndex() {
         return this.projectIndex !== undefined;
     }
+    async refreshIndex() {
+        try {
+            if (this.projectIndex) {
+                await this.projectIndex.refreshFromWorkspace();
+            }
+            else {
+                this.projectIndex = await buildProjectIndex(this.config.workspaceRoot);
+                this.installToolRegistry(this.projectIndex);
+                if (this.modelClient) {
+                    this.agent = this.createAgent(this.agent?.getSession());
+                }
+            }
+            const index = this.projectIndex;
+            if (!index) {
+                return false;
+            }
+            const cacheDir = getWorkspaceCacheDir(this.config.workspaceRoot);
+            const fileHashes = await computeFileHashes(this.config.workspaceRoot);
+            await saveIndex(index, cacheDir, fileHashes);
+            this.evictStaleAnnotations();
+            return true;
+        }
+        catch (error) {
+            if (this.verbose) {
+                const message = error instanceof Error ? error.message : String(error);
+                console.error(`[index] Refresh failed: ${message}`);
+            }
+            return false;
+        }
+    }
     getSymbols() {
         if (!this.projectIndex)
             return [];

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

@@ -6,13 +6,14 @@ import { fileURLToPath } from "node:url";
 import { AgentBridge } from "./agent-bridge.js";
 import { createWebSocketServer } from "./websocket.js";
 import { handleChatCompletions, handleModels } from "./openai-compat.js";
-import { formatConfigForDisplay, getConfigMissing } from "../agent/config.js";
+import { formatConfigForDisplay, getConfiguredProvider, getConfigMissing, resolveConfigEnv } 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";
+import { DuplicateSessionLabelError } from "../session/session-store.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
@@ -30,6 +31,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 = [];
@@ -38,6 +52,9 @@ function readBody(req) {
         req.on("error", reject);
     });
 }
+function normalizeBaseUrl(value) {
+    return value.trim().replace(/\/+$/, "");
+}
 async function serveStatic(res, urlPath) {
     const fileName = urlPath === "/" ? "index.html" : urlPath.slice(1);
     const filePath = path.join(webDir, fileName);
@@ -94,13 +111,16 @@ export function createRequestHandler(bridge, emit, options = {}) {
             // Minicode REST API
             if (pathname === "/api/status" && method === "GET") {
                 const missing = getConfigMissing(config);
+                const resolvedEnv = await resolveConfigEnv({ ...(minicodeHome ? { minicodeHome } : {}) });
                 sendJson(res, 200, {
                     status: bridge.isBusy() ? "busy" : "ready",
                     workspace: config.workspaceRoot,
                     model: config.model,
                     provider: config.modelProvider,
                     baseUrl: config.openAiBaseUrl,
+                    configuredProvider: getConfiguredProvider(config, resolvedEnv.values),
                     sessionOpenRouterConnected: bridge.isOpenRouterSessionConnected(),
+                    sessionOpenAiCompatibleConnected: bridge.isOpenAiCompatibleSessionConnected(),
                     needsSetup: missing.length > 0,
                     missing,
                 });
@@ -210,6 +230,84 @@ export function createRequestHandler(bridge, emit, options = {}) {
                 });
                 return;
             }
+            if (pathname === "/api/openai-compatible/connect" && method === "POST") {
+                const body = JSON.parse(await readBody(req));
+                if (!body.baseUrl || typeof body.baseUrl !== "string") {
+                    sendJson(res, 400, { error: "baseUrl is required" });
+                    return;
+                }
+                const normalizedBaseUrl = normalizeBaseUrl(body.baseUrl);
+                if (!normalizedBaseUrl) {
+                    sendJson(res, 400, { error: "baseUrl is required" });
+                    return;
+                }
+                try {
+                    const parsedUrl = new URL(normalizedBaseUrl);
+                    if (!["http:", "https:"].includes(parsedUrl.protocol)) {
+                        throw new Error("invalid protocol");
+                    }
+                }
+                catch {
+                    sendJson(res, 400, { error: "baseUrl must be a valid absolute http(s) URL" });
+                    return;
+                }
+                try {
+                    bridge.connectOpenAiCompatible(normalizedBaseUrl, body.apiKey);
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : "Failed to configure the OpenAI-compatible provider";
+                    sendJson(res, message === "busy" ? 409 : 400, { error: message });
+                    return;
+                }
+                let persistedToEnv = false;
+                let persistedEnvPath = null;
+                let persistWarning = null;
+                const trimmedApiKey = body.apiKey?.trim() ?? "";
+                if (body.persistToEnv === true) {
+                    try {
+                        const result = await upsertHomeEnvValues({
+                            values: {
+                                MODEL_PROVIDER: "openai-compatible",
+                                OPENAI_BASE_URL: normalizedBaseUrl,
+                                OPENAI_API_KEY: trimmedApiKey.length > 0 ? trimmedApiKey : null,
+                            },
+                            ...(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 = `The OpenAI-compatible provider 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
+                            ? "The OpenAI-compatible provider connected for this serve session and was saved to ~/.minicode/.env. Select a model to continue, and minicode will remember this endpoint for future runs."
+                            : "The OpenAI-compatible provider connected for this serve session and was saved to ~/.minicode/.env for future runs.")
+                        : (onlyModelMissing
+                            ? "The OpenAI-compatible provider connected for this serve session. Select a model to continue."
+                            : "The OpenAI-compatible provider 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 {
@@ -237,6 +335,33 @@ export function createRequestHandler(bridge, emit, options = {}) {
                 sendJson(res, 200, body);
                 return;
             }
+            if (pathname === "/api/openai-compatible/disconnect" && method === "POST") {
+                let disconnected = false;
+                try {
+                    disconnected = bridge.disconnectOpenAiCompatible();
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : "Failed to remove the OpenAI-compatible 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 OpenAI-compatible connection and restored your original provider settings."
+                        : "No session-only OpenAI-compatible 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") {
@@ -323,8 +448,16 @@ export function createRequestHandler(bridge, emit, options = {}) {
             }
             if (pathname === "/api/sessions/save" && method === "POST") {
                 const body = JSON.parse(await readBody(req));
-                const meta = await bridge.saveSess(body.label);
-                sendJson(res, 200, meta);
+                try {
+                    const meta = await bridge.saveSess(body.label);
+                    sendJson(res, 200, meta);
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : "Failed to save session";
+                    sendJson(res, error instanceof DuplicateSessionLabelError ? 409 : 500, {
+                        error: message,
+                    });
+                }
                 return;
             }
             if (pathname === "/api/sessions/load" && method === "POST") {
@@ -423,6 +556,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;
@@ -443,6 +592,20 @@ export function createRequestHandler(bridge, emit, options = {}) {
                 sendJson(res, 200, result);
                 return;
             }
+            if (pathname === "/api/index/refresh" && method === "POST") {
+                const refreshed = await bridge.refreshIndex();
+                if (!refreshed) {
+                    sendJson(res, 404, { error: "No project index available" });
+                    return;
+                }
+                const graph = bridge.getGraph();
+                sendJson(res, 200, {
+                    ok: true,
+                    symbolCount: graph?.nodes.length ?? 0,
+                    edgeCount: graph?.edges.length ?? 0,
+                });
+                return;
+            }
             if (pathname === "/api/analysis" && method === "GET") {
                 const result = bridge.getStructuralAnalysis();
                 if (!result) {

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

@@ -3,10 +3,23 @@ import os from "node:os";
 import path from "node:path";
 import { Session } from "@minicode/agent-sdk";
 let sessionsDir = path.join(os.homedir(), ".minicode", "sessions");
+export class DuplicateSessionLabelError extends Error {
+    label;
+    existingSessionId;
+    constructor(label, existingSessionId) {
+        super(`A saved session named "${label}" already exists. Choose a different name or load that session to update it.`);
+        this.label = label;
+        this.existingSessionId = existingSessionId;
+        this.name = "DuplicateSessionLabelError";
+    }
+}
 /** Override sessions directory (for testing). */
 export function setSessionsDir(dir) {
     sessionsDir = dir;
 }
+function normalizeSessionLabel(label) {
+    return label.trim().toLowerCase();
+}
 export async function saveSession(session, label, annotations) {
     await mkdir(sessionsDir, { recursive: true });
     const savedAt = new Date().toISOString();
@@ -14,6 +27,11 @@ export async function saveSession(session, label, annotations) {
     const resolvedLabel = label && label.trim().length > 0
         ? label.trim()
         : new Date().toLocaleString();
+    const duplicate = (await listSessions()).find((savedSession) => savedSession.id !== snapshot.id &&
+        normalizeSessionLabel(savedSession.label) === normalizeSessionLabel(resolvedLabel));
+    if (duplicate) {
+        throw new DuplicateSessionLabelError(resolvedLabel, duplicate.id);
+    }
     const data = {
         label: resolvedLabel,
         savedAt,