@sean.holung/minicode 0.3.2 → 0.3.3

package/README.md

@@ -1,13 +1,13 @@
 # minicode
 
-A lightweight coding agent optimized for **local models** — CLI-first with a built-in web UI. Provides AST-based intelligent context for smaller models running on consumer hardware.
+A graph-native coding agent and code exploration environment built around structural context optimization. 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.
 
-_New Web UI interface with code dependency graph visualizer. Updates in real time as agent explores the codebase. Run `minicode serve` to interact over localhost._
+_Run `minicode serve` to get the web UI on localhost: chat, tool activity, session controls, model switching, symbol focus, annotations, and a live dependency graph._
 
 <img width="1723" height="920" alt="Screenshot 2026-03-26 at 6 30 23 PM" src="https://github.com/user-attachments/assets/499c8dc7-cc2b-4125-abd5-32b2fc9795ea" />
 
 
-Read operations dominate token usage in typical agent sessions; minicode addresses this by optimizing for **specific languages** — indexing your project at startup with language plugins (TypeScript/JavaScript built-in) and injecting a compact **code map** (signatures only) into the system prompt, plus symbol-level tools (`read_symbol`, `find_references`, `get_dependencies`) so the model reads only what it needs instead of entire files. This keeps prompts lean enough for smaller models in the 20B range, with faster inference and better attention over the relevant code.
+Read operations dominate token usage in typical agent sessions; minicode addresses this by optimizing for **specific languages**. It indexes your project at startup with language plugins, injects a compact **code map** (signatures only) into the system prompt, and exposes symbol-level tools (`read_symbol`, `find_references`, `get_dependencies`) so the model reads only what it needs instead of entire files. TypeScript and JavaScript support come built-in, with custom language plugins leaving room for broader language support over time.
 
 ## Quick Start (LM Studio)
 
@@ -17,22 +17,11 @@ Read operations dominate token usage in typical agent sessions; minicode address
 # 2. Install
 npm install -g @sean.holung/minicode
 
-# 3. Configure for local (no API key needed)
-mkdir -p ~/.minicode
+# 3. Configure (~/.minicode/agent.config.json is auto-created on first run)
+#    Set your model name — minicode will prompt you if this is missing.
 cat > ~/.minicode/.env << 'EOF'
 MODEL_PROVIDER=openai-compatible
-MODEL=zai-org/glm-4.7-flash
-OPENAI_BASE_URL=http://localhost:1234/v1
-OPENAI_API_KEY=
-MAX_STEPS=50
-MAX_TOKENS=4096
-MAX_CONTEXT_TOKENS=24000
-WORKSPACE_ROOT=.
-COMMAND_TIMEOUT_MS=30000
-MAX_FILE_SIZE_BYTES=1000000
-CONFIRM_DESTRUCTIVE=true
-KEEP_RECENT_MESSAGES=12
-LOOP_DETECTION_WINDOW=6
+MODEL=your-model-name
 EOF
 ```
 
@@ -97,7 +86,7 @@ npm run install:global
 - **Web UI** — `minicode serve` starts an HTTP + WebSocket server with a bundled chat client, real-time streaming, session management, and project graph data endpoints
 - **OpenAI-compatible API** — any client that speaks the OpenAI protocol can use minicode as a backend at `/v1/chat/completions`
 - **Context optimization:** Code map in system prompt, `read_symbol`, `find_references`, `get_dependencies`
-- **Plugin system:** Extensible language support (TypeScript built-in)
+- **Plugin system:** Extensible language support (TypeScript/JavaScript built in today)
 
 ## Context Optimization
 
@@ -110,9 +99,9 @@ For the proposed reusable package architecture and public interfaces for a stand
 minicode reduces token usage by indexing your project and providing targeted tools:
 
 - **Code map** — A compact project skeleton (signatures only) is injected into the system prompt so the model can orient itself without reading full files.
-- `**read_symbol`** — Read a specific function or class by name, with referenced types.
-- `**find_references**` — Find all symbols that reference a given symbol.
-- `**get_dependencies**` — Get the dependency cone of a symbol.
+- `read_symbol` — Read a specific function or class by name, with referenced types.
+- `find_references` — Find all symbols that reference a given symbol.
+- `get_dependencies` — Get the dependency cone of a symbol.
 
 The index is cached in `~/.minicode/cache/<workspace-hash>/` for faster startup on subsequent runs. Caches are global and keyed by workspace path, so nothing is stored inside your project directories.
 
@@ -175,9 +164,9 @@ See [docs/PLUGIN_SPEC.md](docs/PLUGIN_SPEC.md) for the full specification. Quick
 
 Configuration can come from (later sources override earlier):
 
-1. `**~/.minicode/.env`** — User-level defaults (API keys, model, etc.)
-2. `**~/.minicode/agent.config.json**` — User-level JSON config
-3. **Project `.env`** and `**agent.config.json**` in workspace root
+1. `~/.minicode/.env` — User-level defaults (API keys, model, etc.)
+2. `~/.minicode/agent.config.json` — User-level JSON config
+3. Project `.env` and `agent.config.json` in workspace root
 4. Environment variables (highest precedence)
 
 Nothing is written inside your workspace; config and cache live under `~/.minicode/`.
@@ -188,45 +177,41 @@ Nothing is written inside your workspace; config and cache live under `~/.minico
 | Variable                | Required        | Default                    | Notes                                                                                                                                 |
 | ----------------------- | --------------- | -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- |
 | `MODEL_PROVIDER`        | No              | `openai-compatible`        | `anthropic` or `openai-compatible` (aliases: `openai`, `lmstudio`, `lm-studio`)                                                       |
-| `MODEL`                 | No              | `zai-org/glm-4.7-flash`    | Model name for selected provider                                                                                                      |
+| `MODEL`                 | Yes             | none                       | Model name for selected provider                                                                                                      |
 | `ANTHROPIC_API_KEY`     | Yes (Anthropic) | none                       | Required when `MODEL_PROVIDER=anthropic`                                                                                              |
 | `OPENAI_BASE_URL`       | No              | `http://localhost:1234/v1` | Base URL for OpenAI-compatible API (LM Studio, etc.)                                                                                  |
 | `OPENAI_API_KEY`        | No              | none                       | Optional for local servers; required if your endpoint enforces auth                                                                   |
+| `OPENROUTER_API_KEY`    | No              | none                       | Preferred key when `OPENAI_BASE_URL` points at OpenRouter; falls back to `OPENAI_API_KEY` if unset                                  |
 | `MAX_STEPS`             | No              | `50`                       | Max agent loop iterations per user turn                                                                                               |
 | `MAX_TOKENS`            | No              | `4096`                     | Max model output tokens per model call                                                                                                |
-| `MAX_CONTEXT_TOKENS`    | No              | `120000`                   | 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              | `15000`                    | 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                                                                                            |
+| `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)                                                  |
 | `COMMAND_TIMEOUT_MS`    | No              | `30000`                    | Timeout for shell/search commands                                                                                                     |
 | `MAX_FILE_SIZE_BYTES`   | No              | `1000000`                  | Read limit for `read_file`                                                                                                            |
 | `CONFIRM_DESTRUCTIVE`   | No              | `true`                     | If `true`, blocks destructive shell commands unless confirmed                                                                         |
 | `KEEP_RECENT_MESSAGES`  | No              | `12`                       | Minimum number of latest messages kept during trimming                                                                                |
 | `LOOP_DETECTION_WINDOW` | No              | `6`                        | Window for repeated tool-call loop detection                                                                                          |
+| `ENABLE_FILE_READ_DEDUP` | No             | `true`                     | Reuses earlier `read_file` results within a turn when the same file slice is still in context                                        |
+| `ENABLE_ADAPTIVE_KEEP_RECENT` | No        | `true`                     | Scales `keepRecentMessages` down as context fills so trimming gets more aggressive when needed                                       |
+| `ENABLE_TOOL_OUTPUT_TRUNCATION` | No      | `true`                     | Enables content-aware truncation strategies for tool output instead of simple head-only clipping                                     |
 | `COMPACTION_THRESHOLD`  | No              | `0.8`                      | Context fullness ratio (0–1) at which auto-compaction triggers                                                                        |
 | `COMPACTION_MODEL`      | No              | none                       | Model for LLM-based compaction summaries. When set, `/compact` and auto-compaction use this model instead of mechanical truncation. Use a small, fast model (e.g. your local model). |
+| `REASONING_EFFORT`      | No              | unset                      | Reasoning level for providers that support it. Valid values: `xhigh`, `high`, `medium`, `low`, `minimal`, `none`                   |
 
 
 ### `agent.config.json`
 
-Create `agent.config.json` in `~/.minicode/` for user-level defaults, or in the project root for workspace-specific overrides:
+A global `~/.minicode/agent.config.json` is auto-created on first run. Only set what you need — everything has sensible defaults:
 
 ```json
 {
   "modelProvider": "openai-compatible",
-  "model": "zai-org/glm-4.7-flash",
+  "model": "your-model-name",
+  "openAiBaseUrl": "http://localhost:1234/v1",
   "maxSteps": 50,
   "maxTokens": 4096,
-  "maxContextTokens": 120000,
-  "workspaceRoot": ".",
-  "commandTimeout": 30000,
-  "commandDenylist": [],
-  "confirmDestructive": true,
-  "maxFileSizeBytes": 1000000,
-  "keepRecentMessages": 12,
-  "loopDetectionWindow": 6,
-  "openAiBaseUrl": "http://localhost:1234/v1",
-  "openAiApiKey": "",
-  "compactionModel": ""
+  "maxContextTokens": 32000
 }
 ```
 
@@ -245,9 +230,14 @@ Field mapping:
 - `keepRecentMessages` ↔ `KEEP_RECENT_MESSAGES`
 - `loopDetectionWindow` ↔ `LOOP_DETECTION_WINDOW`
 - `openAiBaseUrl` ↔ `OPENAI_BASE_URL`
-- `openAiApiKey` ↔ `OPENAI_API_KEY`
+- `openAiApiKey` ↔ `OPENAI_API_KEY` / `OPENROUTER_API_KEY` (when using OpenRouter)
+- `maxToolOutputChars` ↔ `MAX_TOOL_OUTPUT_CHARS`
+- `enableFileReadDedup` ↔ `ENABLE_FILE_READ_DEDUP`
+- `enableAdaptiveKeepRecent` ↔ `ENABLE_ADAPTIVE_KEEP_RECENT`
+- `enableToolOutputTruncation` ↔ `ENABLE_TOOL_OUTPUT_TRUNCATION`
 - `compactionThreshold` ↔ `COMPACTION_THRESHOLD`
 - `compactionModel` ↔ `COMPACTION_MODEL`
+- `reasoningEffort` ↔ `REASONING_EFFORT`
 
 ## Usage
 
@@ -278,6 +268,19 @@ npm run dev -- --oneshot --json "Summarize TODOs"
 npm run dev -- --oneshot --out result.txt "Draft changelog"
 ```
 
+Interactive slash commands:
+
+- `/help`
+- `/config`
+- `/compact`
+- `/reasoning [level]`
+- `/models`
+- `/model [name]`
+- `/save [label]`
+- `/load [label]`
+- `/sessions`
+- `/exit`
+
 ### Exit codes
 
 - `0`: Success
@@ -289,7 +292,9 @@ npm run dev -- --oneshot --out result.txt "Draft changelog"
 - `npm run dev` - start the CLI in TypeScript mode
 - `npm run dev:ink` - start with Ink UI (same as `dev` when in a TTY; use to override `CLI_UI_MODE=legacy`)
 - `npm run build` - compile TypeScript to `dist/`
+- `npm run build:web` - build the bundled web client used by `minicode serve`
 - `npm start` - run compiled CLI
+- `npm run install:global` - build and `npm link` the CLI locally
 - `npm run lint` - run ESLint on TypeScript source and tests
 - `npm test` - run Node test suite
-
+- `npm run verify-index` - run the TypeScript index verification harness

package/dist/scripts/run-benchmarks.js

@@ -0,0 +1,147 @@
+#!/usr/bin/env node
+/**
+ * CLI entry point for running benchmark tasks.
+ *
+ * Usage:
+ *   node --import tsx scripts/run-benchmarks.ts [options]
+ *
+ * Options:
+ *   --category <name>   Run only tasks in the given category
+ *   --task <id>         Run a single task by id (e.g. "navigation/find-symbol-definition")
+ *   --variant <label>   Variant label for the report (default: "ci")
+ *   --out <path>        Write the JSON report to a file
+ *
+ * Environment:
+ *   MODEL_PROVIDER, MODEL, OPENAI_BASE_URL, OPENAI_API_KEY, ANTHROPIC_API_KEY
+ *   — same as minicode runtime config.
+ */
+import path from "node:path";
+import { writeFile } from "node:fs/promises";
+import { createModelClient, createReadFileTool, createWriteFileTool, createEditFileTool, createSearchTool, createListFilesTool, createRunCommandTool, } from "@minicode/agent-sdk";
+import { loadBenchmarkTasks, loadBenchmarkTask } from "../src/benchmark/task-loader.js";
+import { runBenchmarkSuite } from "../src/benchmark/runner.js";
+import { buildReport, formatReport } from "../src/benchmark/reporter.js";
+export function parseArgs(argv) {
+    const args = { variant: "ci" };
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        const next = argv[i + 1];
+        if (arg === "--category" && next) {
+            args.category = next;
+            i++;
+        }
+        else if (arg === "--task" && next) {
+            args.task = next;
+            i++;
+        }
+        else if (arg === "--variant" && next) {
+            args.variant = next;
+            i++;
+        }
+        else if (arg === "--out" && next) {
+            args.out = next;
+            i++;
+        }
+    }
+    return args;
+}
+/* ------------------------------------------------------------------ */
+/*  Config builder                                                     */
+/* ------------------------------------------------------------------ */
+export function buildConfig() {
+    const provider = (process.env.MODEL_PROVIDER ?? "openai-compatible");
+    const model = process.env.MODEL ?? "test-model";
+    return {
+        modelProvider: provider,
+        model,
+        maxSteps: Number(process.env.MAX_STEPS ?? "50"),
+        maxTokens: Number(process.env.MAX_TOKENS ?? "4096"),
+        maxContextTokens: Number(process.env.MAX_CONTEXT_TOKENS ?? "32000"),
+        workspaceRoot: process.cwd(),
+        commandTimeoutMs: Number(process.env.COMMAND_TIMEOUT_MS ?? "30000"),
+        maxFileSizeBytes: Number(process.env.MAX_FILE_SIZE_BYTES ?? "1000000"),
+        commandDenylist: [],
+        confirmDestructive: false,
+        keepRecentMessages: Number(process.env.KEEP_RECENT_MESSAGES ?? "12"),
+        loopDetectionWindow: Number(process.env.LOOP_DETECTION_WINDOW ?? "6"),
+        maxToolOutputChars: Number(process.env.MAX_TOOL_OUTPUT_CHARS ?? "8000"),
+        openAiBaseUrl: process.env.OPENAI_BASE_URL ?? "http://localhost:1234/v1",
+        ...(process.env.OPENAI_API_KEY ? { openAiApiKey: process.env.OPENAI_API_KEY } : {}),
+    };
+}
+/* ------------------------------------------------------------------ */
+/*  Task loading                                                       */
+/* ------------------------------------------------------------------ */
+export async function loadTasks(tasksDir, args) {
+    if (args.task) {
+        const single = await loadBenchmarkTask(tasksDir, args.task);
+        if (!single) {
+            throw new Error(`Task not found: ${args.task}`);
+        }
+        return [single];
+    }
+    let tasks = await loadBenchmarkTasks(tasksDir);
+    if (args.category) {
+        tasks = tasks.filter((t) => t.category === args.category);
+        if (tasks.length === 0) {
+            throw new Error(`No tasks found for category: ${args.category}`);
+        }
+    }
+    return tasks;
+}
+/* ------------------------------------------------------------------ */
+/*  Main                                                               */
+/* ------------------------------------------------------------------ */
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    const config = buildConfig();
+    const tasksDir = path.resolve(process.cwd(), "benchmarks", "tasks");
+    console.log(`Benchmark runner starting...`);
+    console.log(`  Provider: ${config.modelProvider}`);
+    console.log(`  Model: ${config.model}`);
+    console.log(`  Variant: ${args.variant}`);
+    const tasks = await loadTasks(tasksDir, args);
+    console.log(`  Tasks: ${tasks.length}`);
+    console.log("");
+    const modelClient = createModelClient(config);
+    const tools = [
+        createReadFileTool(config),
+        createWriteFileTool(config),
+        createEditFileTool(config),
+        createSearchTool(config),
+        createListFilesTool(config),
+        createRunCommandTool(config),
+    ];
+    const traces = await runBenchmarkSuite(tasks, {
+        modelClient,
+        config,
+        tools,
+        variant: args.variant,
+        onTaskComplete: (taskId, trace) => {
+            const dur = (trace.durationMs / 1000).toFixed(1);
+            console.log(`  [done] ${taskId} (${dur}s, ${trace.toolCalls.length} tool calls)`);
+        },
+    });
+    const report = buildReport(tasks, traces, args.variant, config.model);
+    const formatted = formatReport(report);
+    console.log("");
+    console.log(formatted);
+    if (args.out) {
+        const outPath = path.resolve(args.out);
+        await writeFile(outPath, JSON.stringify(report, null, 2), "utf8");
+        console.log(`\nReport written to ${outPath}`);
+    }
+    // Exit with failure if any task failed
+    if (report.summary.failed > 0) {
+        process.exitCode = 1;
+    }
+}
+// Only run main when executed directly (not imported for testing)
+const isDirectRun = process.argv[1]?.endsWith("run-benchmarks.ts") ||
+    process.argv[1]?.endsWith("run-benchmarks.js");
+if (isDirectRun) {
+    main().catch((err) => {
+        console.error("Benchmark runner failed:", err);
+        process.exitCode = 1;
+    });
+}

package/dist/src/agent/config.js

@@ -1,8 +1,7 @@
-import { access, readFile } from "node:fs/promises";
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import process from "node:process";
-import { fileURLToPath } from "node:url";
 import dotenv from "dotenv";
 /** User-level config directory: ~/.minicode */
 export const MINICODE_HOME = path.join(os.homedir(), ".minicode");
@@ -32,17 +31,52 @@ export function formatConfigForDisplay(config) {
         "enableToolOutputTruncation: " + (config.enableToolOutputTruncation ?? false),
         "compactionThreshold: " + (config.compactionThreshold ?? "(disabled)"),
         "compactionModel: " + (config.compactionModel ?? "(disabled — using mechanical compaction)"),
+        "reasoningEffort: " + (config.reasoningEffort ?? "(unset — no reasoning parameters sent)"),
+        "enableDynamicPrompt: " + (config.enableDynamicPrompt ?? true),
     ];
     return lines.join("\n");
 }
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const envPath = __dirname.includes(`${path.sep}dist${path.sep}`)
-    ? path.resolve(__dirname, "../../../.env")
-    : path.resolve(__dirname, "../../.env");
-// Load order: user home (~/.minicode/.env) < project .env < cwd .env
-dotenv.config({ path: path.join(MINICODE_HOME, ".env") });
-dotenv.config({ path: envPath, override: true });
-dotenv.config({ path: path.resolve(process.cwd(), ".env"), override: true });
+/**
+ * Check if the config has enough information to connect to a model provider.
+ * Returns null if valid, or a user-facing setup message if not.
+ */
+/**
+ * Return a list of missing config items that prevent the agent from running.
+ * Empty array means the config is valid.
+ */
+export function getConfigMissing(config) {
+    const missing = [];
+    if (!config.model) {
+        missing.push("MODEL is not set");
+    }
+    if (config.modelProvider === "anthropic" && !process.env.ANTHROPIC_API_KEY) {
+        missing.push("ANTHROPIC_API_KEY is not set");
+    }
+    return missing;
+}
+export function getConfigSetupMessage(config) {
+    const missing = getConfigMissing(config);
+    if (missing.length === 0) {
+        return null;
+    }
+    return [
+        "minicode is not configured yet. Missing:",
+        ...missing.map((m) => `  - ${m}`),
+        "",
+        `Set these in ~/.minicode/.env or as environment variables.`,
+        `Edit ~/.minicode/agent.config.json for non-secret settings.`,
+        "",
+        "Example ~/.minicode/.env for a local model:",
+        "  MODEL_PROVIDER=openai-compatible",
+        "  OPENAI_BASE_URL=http://localhost:1234/v1",
+        "  MODEL=your-model-name",
+        "",
+        "Example for Anthropic:",
+        "  MODEL_PROVIDER=anthropic",
+        "  ANTHROPIC_API_KEY=sk-ant-...",
+        "  MODEL=claude-sonnet-4-20250514",
+    ].join("\n");
+}
 const DEFAULT_COMMAND_DENYLIST = [
     /\brm\s+-rf\s+\//i,
     /\bmkfs\b/i,
@@ -54,6 +88,15 @@ const DEFAULT_COMMAND_DENYLIST = [
     /\binit\s+0\b/i,
     /\bchmod\s+-R\s+777\s+\//i,
 ];
+const VALID_REASONING_EFFORTS = new Set([
+    "xhigh", "high", "medium", "low", "minimal", "none",
+]);
+function parseReasoningEffort(value) {
+    if (!value)
+        return undefined;
+    const normalized = value.trim().toLowerCase();
+    return VALID_REASONING_EFFORTS.has(normalized) ? normalized : undefined;
+}
 function parseNumber(value, fallback) {
     if (!value) {
         return fallback;
@@ -74,7 +117,7 @@ function parseBoolean(value, fallback) {
     }
     return fallback;
 }
-async function loadConfigFile(configPath) {
+export async function loadConfigFile(configPath) {
     try {
         await access(configPath);
     }
@@ -88,6 +131,48 @@ async function loadConfigFile(configPath) {
     }
     return parsed;
 }
+async function loadDotenvFile(envPath) {
+    try {
+        const file = await readFile(envPath, "utf8");
+        return dotenv.parse(file);
+    }
+    catch {
+        return {};
+    }
+}
+function applyEnvLayer(target, sources, layer, source, override) {
+    for (const [key, value] of Object.entries(layer)) {
+        if (!override && target[key] !== undefined) {
+            continue;
+        }
+        target[key] = value;
+        sources[key] = source;
+    }
+}
+function applyProcessEnv(target, sources) {
+    for (const [key, value] of Object.entries(process.env)) {
+        if (value === undefined) {
+            continue;
+        }
+        target[key] = value;
+        sources[key] = "process";
+    }
+}
+export async function resolveConfigEnv(options = {}) {
+    const minicodeHome = options.minicodeHome ?? MINICODE_HOME;
+    const homeEnvPath = path.join(minicodeHome, ".env");
+    const values = {};
+    const sources = {};
+    // Base: ~/.minicode/.env
+    applyEnvLayer(values, sources, await loadDotenvFile(homeEnvPath), "home-dotenv", true);
+    // Override: shell environment variables take precedence
+    applyProcessEnv(values, sources);
+    return {
+        values,
+        sources,
+        homeEnvPath,
+    };
+}
 function parseUserDenylist(patterns) {
     if (!patterns?.length) {
         return [];
@@ -113,51 +198,75 @@ function parseModelProvider(value) {
     }
     return "anthropic";
 }
-export async function loadAgentConfig(cwd = process.cwd()) {
-    const homeConfigPath = path.join(MINICODE_HOME, "agent.config.json");
-    const workspaceConfigPath = path.resolve(cwd, "agent.config.json");
-    const homeConfig = await loadConfigFile(homeConfigPath);
-    const workspaceConfig = await loadConfigFile(workspaceConfigPath);
-    const fileConfig = { ...homeConfig, ...workspaceConfig };
-    const rawWorkspaceRoot = process.env.WORKSPACE_ROOT ?? fileConfig.workspaceRoot ?? cwd;
+const DEFAULT_CONFIG_CONTENT = `{
+  "modelProvider": "openai-compatible",
+  "model": "",
+  "openAiBaseUrl": "http://localhost:1234/v1",
+  "maxSteps": 50,
+  "maxTokens": 4096,
+  "maxContextTokens": 32000
+}
+`;
+async function ensureMinicodeHome(minicodeHome) {
+    await mkdir(minicodeHome, { recursive: true });
+    const configPath = path.join(minicodeHome, "agent.config.json");
+    try {
+        await access(configPath);
+    }
+    catch {
+        await writeFile(configPath, DEFAULT_CONFIG_CONTENT, "utf8");
+    }
+}
+export async function loadAgentConfig(cwd = process.cwd(), options = {}) {
+    const minicodeHome = options.minicodeHome ?? MINICODE_HOME;
+    await ensureMinicodeHome(minicodeHome);
+    const homeConfigPath = path.join(minicodeHome, "agent.config.json");
+    const fileConfig = await loadConfigFile(homeConfigPath);
+    const env = (await resolveConfigEnv({ minicodeHome })).values;
+    const rawWorkspaceRoot = env.WORKSPACE_ROOT ?? fileConfig.workspaceRoot ?? cwd;
     const workspaceRoot = path.resolve(cwd, rawWorkspaceRoot);
     const commandDenylist = [
         ...DEFAULT_COMMAND_DENYLIST,
         ...parseUserDenylist(fileConfig.commandDenylist),
     ];
-    const rawBaseUrl = process.env.OPENAI_BASE_URL ??
+    const rawBaseUrl = env.OPENAI_BASE_URL ??
         fileConfig.openAiBaseUrl ??
         "http://localhost:1234/v1";
     const isOpenRouter = rawBaseUrl.includes("openrouter");
     const openAiApiKey = isOpenRouter
-        ? (process.env.OPENROUTER_API_KEY ??
-            process.env.OPENAI_API_KEY ??
+        ? (env.OPENROUTER_API_KEY ??
+            env.OPENAI_API_KEY ??
             fileConfig.openAiApiKey)
-        : (process.env.OPENAI_API_KEY ?? fileConfig.openAiApiKey);
+        : (env.OPENAI_API_KEY ?? fileConfig.openAiApiKey);
     return {
-        modelProvider: parseModelProvider(process.env.MODEL_PROVIDER ?? fileConfig.modelProvider ?? "openai-compatible"),
-        model: process.env.MODEL ??
+        modelProvider: parseModelProvider(env.MODEL_PROVIDER ?? fileConfig.modelProvider ?? "openai-compatible"),
+        model: env.MODEL ??
             fileConfig.model ??
-            "zai-org/glm-4.7-flash",
-        maxSteps: parseNumber(process.env.MAX_STEPS, fileConfig.maxSteps ?? 50),
-        maxTokens: parseNumber(process.env.MAX_TOKENS, fileConfig.maxTokens ?? 4096),
-        maxContextTokens: parseNumber(process.env.MAX_CONTEXT_TOKENS, fileConfig.maxContextTokens ?? 40_000),
+            "",
+        maxSteps: parseNumber(env.MAX_STEPS, fileConfig.maxSteps ?? 50),
+        maxTokens: parseNumber(env.MAX_TOKENS, fileConfig.maxTokens ?? 4096),
+        maxContextTokens: parseNumber(env.MAX_CONTEXT_TOKENS, fileConfig.maxContextTokens ?? 32_000),
         workspaceRoot,
-        commandTimeoutMs: parseNumber(process.env.COMMAND_TIMEOUT_MS, fileConfig.commandTimeout ?? 30_000),
-        maxFileSizeBytes: parseNumber(process.env.MAX_FILE_SIZE_BYTES, fileConfig.maxFileSizeBytes ?? 1_000_000),
+        commandTimeoutMs: parseNumber(env.COMMAND_TIMEOUT_MS, fileConfig.commandTimeout ?? 30_000),
+        maxFileSizeBytes: parseNumber(env.MAX_FILE_SIZE_BYTES, fileConfig.maxFileSizeBytes ?? 1_000_000),
         commandDenylist,
-        confirmDestructive: parseBoolean(process.env.CONFIRM_DESTRUCTIVE, fileConfig.confirmDestructive ?? true),
-        keepRecentMessages: parseNumber(process.env.KEEP_RECENT_MESSAGES, fileConfig.keepRecentMessages ?? 12),
-        loopDetectionWindow: parseNumber(process.env.LOOP_DETECTION_WINDOW, fileConfig.loopDetectionWindow ?? 6),
-        maxToolOutputChars: parseNumber(process.env.MAX_TOOL_OUTPUT_CHARS, fileConfig.maxToolOutputChars ?? 8_000),
+        confirmDestructive: parseBoolean(env.CONFIRM_DESTRUCTIVE, fileConfig.confirmDestructive ?? true),
+        keepRecentMessages: parseNumber(env.KEEP_RECENT_MESSAGES, fileConfig.keepRecentMessages ?? 12),
+        loopDetectionWindow: parseNumber(env.LOOP_DETECTION_WINDOW, fileConfig.loopDetectionWindow ?? 6),
+        maxToolOutputChars: parseNumber(env.MAX_TOOL_OUTPUT_CHARS, fileConfig.maxToolOutputChars ?? 8_000),
         openAiBaseUrl: rawBaseUrl,
         ...(openAiApiKey !== undefined ? { openAiApiKey } : {}),
-        enableFileReadDedup: parseBoolean(process.env.ENABLE_FILE_READ_DEDUP, fileConfig.enableFileReadDedup ?? true),
-        enableAdaptiveKeepRecent: parseBoolean(process.env.ENABLE_ADAPTIVE_KEEP_RECENT, fileConfig.enableAdaptiveKeepRecent ?? true),
-        enableToolOutputTruncation: parseBoolean(process.env.ENABLE_TOOL_OUTPUT_TRUNCATION, fileConfig.enableToolOutputTruncation ?? true),
-        compactionThreshold: parseNumber(process.env.COMPACTION_THRESHOLD, fileConfig.compactionThreshold ?? 0.8),
-        ...(process.env.COMPACTION_MODEL ?? fileConfig.compactionModel
-            ? { compactionModel: process.env.COMPACTION_MODEL ?? fileConfig.compactionModel }
+        enableFileReadDedup: parseBoolean(env.ENABLE_FILE_READ_DEDUP, fileConfig.enableFileReadDedup ?? true),
+        enableAdaptiveKeepRecent: parseBoolean(env.ENABLE_ADAPTIVE_KEEP_RECENT, fileConfig.enableAdaptiveKeepRecent ?? true),
+        enableToolOutputTruncation: parseBoolean(env.ENABLE_TOOL_OUTPUT_TRUNCATION, fileConfig.enableToolOutputTruncation ?? true),
+        compactionThreshold: parseNumber(env.COMPACTION_THRESHOLD, fileConfig.compactionThreshold ?? 0.8),
+        ...(env.COMPACTION_MODEL ?? fileConfig.compactionModel
+            ? { compactionModel: env.COMPACTION_MODEL ?? fileConfig.compactionModel }
             : {}),
+        enableDynamicPrompt: parseBoolean(env.ENABLE_DYNAMIC_PROMPT, fileConfig.enableDynamicPrompt ?? true),
+        ...(() => {
+            const effort = parseReasoningEffort(env.REASONING_EFFORT ?? fileConfig.reasoningEffort);
+            return effort ? { reasoningEffort: effort } : {};
+        })(),
     };
 }