@sean.holung/minicode 0.3.4 → 0.3.6

package/README.md

@@ -1,13 +1,27 @@
 # minicode
 
-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.
+> 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.
+
+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. 
+
+minicode is built on a simple bet: models perform better when you give them less, but better context. Bloated context directly degrades output quality: attention dilutes, positional biases cause mid-context information loss, and inference latency grows as token count increases.
+
+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. This also enables the agent to walk the code structurally to gain a better understanding of the codebase at a structural level. TypeScript and JavaScript support come built-in, with custom language plugins leaving room for broader language support over time.
 
 _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" />
 
+## Quick Start (OpenRouter)
+```bash
+npm install -g @sean.holung/minicode
+minicode serve
+```
+
+1. Navigate to [localhost:4567](http://localhost:4567)
+2. Click Connect OpenRouter to sign in to [OpenRouter](https://openrouter.ai/) and connect account.
+3. Choose a model. Choose a (free) model if on free tier. Model must support tool use.
 
-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,8 +31,8 @@ Read operations dominate token usage in typical agent sessions; minicode address
 # 2. Install
 npm install -g @sean.holung/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.
+# 3. Configure
+#    Set your model name in ~/.minicode/.env — minicode will prompt you if this is missing.
 cat > ~/.minicode/.env << 'EOF'
 MODEL_PROVIDER=openai-compatible
 MODEL=your-model-name
@@ -162,12 +176,12 @@ See [docs/PLUGIN_SPEC.md](docs/PLUGIN_SPEC.md) for the full specification. Quick
 
 ## Configuration
 
-Configuration can come from (later sources override earlier):
+Configuration can come from:
+
+1. `~/.minicode/.env` — User-level defaults (API keys, model, runtime settings)
+2. Environment variables — Shell overrides for the current process
 
-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)
+When the same key is set in both places, the exported environment variable wins.
 
 Nothing is written inside your workspace; config and cache live under `~/.minicode/`.
 
@@ -182,6 +196,7 @@ Nothing is written inside your workspace; config and cache live under `~/.minico
 | `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                                  |
+| `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                                                                                                |
 | `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. |
@@ -200,44 +215,7 @@ Nothing is written inside your workspace; config and cache live under `~/.minico
 | `REASONING_EFFORT`      | No              | unset                      | Reasoning level for providers that support it. Valid values: `xhigh`, `high`, `medium`, `low`, `minimal`, `none`                   |
 
 
-### `agent.config.json`
-
-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": "your-model-name",
-  "openAiBaseUrl": "http://localhost:1234/v1",
-  "maxSteps": 50,
-  "maxTokens": 4096,
-  "maxContextTokens": 32000
-}
-```
-
-Field mapping:
-
-- `modelProvider` ↔ `MODEL_PROVIDER`
-- `model` ↔ `MODEL`
-- `maxSteps` ↔ `MAX_STEPS`
-- `workspaceRoot` ↔ `WORKSPACE_ROOT`
-- `maxTokens` ↔ `MAX_TOKENS`
-- `maxContextTokens` ↔ `MAX_CONTEXT_TOKENS`
-- `commandTimeout` ↔ `COMMAND_TIMEOUT_MS`
-- `commandDenylist` ↔ no env equivalent (config-only)
-- `confirmDestructive` ↔ `CONFIRM_DESTRUCTIVE`
-- `maxFileSizeBytes` ↔ `MAX_FILE_SIZE_BYTES`
-- `keepRecentMessages` ↔ `KEEP_RECENT_MESSAGES`
-- `loopDetectionWindow` ↔ `LOOP_DETECTION_WINDOW`
-- `openAiBaseUrl` ↔ `OPENAI_BASE_URL`
-- `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`
+All persisted user-level settings now live in `~/.minicode/.env`. The web UI settings dialog and `/config set` both update that file directly for non-secret runtime defaults.
 
 ## Usage
 

package/dist/scripts/run-benchmarks.js

@@ -12,15 +12,20 @@
  *   --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.
+ *   MODEL_PROVIDER, MODEL, OPENAI_BASE_URL, OPENAI_API_KEY, OPENROUTER_API_KEY, ANTHROPIC_API_KEY
+ *   — benchmark-layer overrides for benchmarks/benchmark.config.json.
  */
+import { readFileSync, existsSync } from "node:fs";
 import path from "node:path";
+import { homedir } from "node:os";
 import { writeFile } from "node:fs/promises";
-import { createModelClient, createReadFileTool, createWriteFileTool, createEditFileTool, createSearchTool, createListFilesTool, createRunCommandTool, } from "@minicode/agent-sdk";
+import { createModelClient, } from "@minicode/agent-sdk";
+import { parse as parseDotenv } from "dotenv";
 import { loadBenchmarkTasks, loadBenchmarkTask } from "../src/benchmark/task-loader.js";
 import { runBenchmarkSuite } from "../src/benchmark/runner.js";
 import { buildReport, formatReport } from "../src/benchmark/reporter.js";
+import { buildProjectIndex } from "../src/indexer/project-index.js";
+import { createToolRegistry } from "../src/tools/registry.js";
 export function parseArgs(argv) {
     const args = { variant: "ci" };
     for (let i = 0; i < argv.length; i++) {
@@ -48,25 +53,63 @@ export function parseArgs(argv) {
 /* ------------------------------------------------------------------ */
 /*  Config builder                                                     */
 /* ------------------------------------------------------------------ */
-export function buildConfig() {
-    const provider = (process.env.MODEL_PROVIDER ?? "openai-compatible");
-    const model = process.env.MODEL ?? "test-model";
+export function getBenchmarkConfigPath(repoRoot = process.cwd()) {
+    return path.resolve(repoRoot, "benchmarks", "benchmark.config.json");
+}
+function loadJsonConfigFile(configPath) {
+    if (!existsSync(configPath)) {
+        return {};
+    }
+    return JSON.parse(readFileSync(configPath, "utf8"));
+}
+function loadHomeEnvVars(homeEnvPath) {
+    if (!existsSync(homeEnvPath)) {
+        return {};
+    }
+    return parseDotenv(readFileSync(homeEnvPath, "utf8"));
+}
+function firstDefined(...values) {
+    return values.find((value) => value != null && value.length > 0);
+}
+function getNumberSetting(envValue, fileValue, fallback) {
+    if (envValue != null && envValue.length > 0) {
+        return Number(envValue);
+    }
+    return fileValue ?? fallback;
+}
+export function buildConfig(options = {}) {
+    const repoRoot = path.resolve(options.repoRoot ?? process.cwd());
+    const env = options.env ?? process.env;
+    const homeEnvPath = options.homeEnvPath ?? path.join(homedir(), ".minicode", ".env");
+    const configPath = options.configPath ?? getBenchmarkConfigPath(repoRoot);
+    const fileConfig = loadJsonConfigFile(configPath);
+    const homeEnv = loadHomeEnvVars(homeEnvPath);
+    const getShellOverride = (key) => env[key];
+    const getSecret = (key) => firstDefined(env[key], homeEnv[key]);
+    const provider = (firstDefined(getShellOverride("MODEL_PROVIDER"), fileConfig.modelProvider, "openai-compatible") ?? "openai-compatible");
+    const model = firstDefined(getShellOverride("MODEL"), fileConfig.model, "test-model") ?? "test-model";
+    const openAiBaseUrl = firstDefined(getShellOverride("OPENAI_BASE_URL"), fileConfig.openAiBaseUrl, "http://localhost:1234/v1") ?? "http://localhost:1234/v1";
+    const openAiApiKey = provider === "openai-compatible"
+        ? (openAiBaseUrl.includes("openrouter.ai")
+            ? firstDefined(getSecret("OPENROUTER_API_KEY"), getSecret("OPENAI_API_KEY"))
+            : getSecret("OPENAI_API_KEY"))
+        : undefined;
     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"),
+        maxSteps: getNumberSetting(getShellOverride("MAX_STEPS"), fileConfig.maxSteps, 50),
+        maxTokens: getNumberSetting(getShellOverride("MAX_TOKENS"), fileConfig.maxTokens, 4096),
+        maxContextTokens: getNumberSetting(getShellOverride("MAX_CONTEXT_TOKENS"), fileConfig.maxContextTokens, 32000),
+        workspaceRoot: repoRoot,
+        commandTimeoutMs: getNumberSetting(getShellOverride("COMMAND_TIMEOUT_MS"), fileConfig.commandTimeoutMs, 30000),
+        maxFileSizeBytes: getNumberSetting(getShellOverride("MAX_FILE_SIZE_BYTES"), fileConfig.maxFileSizeBytes, 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 } : {}),
+        keepRecentMessages: getNumberSetting(getShellOverride("KEEP_RECENT_MESSAGES"), fileConfig.keepRecentMessages, 12),
+        loopDetectionWindow: getNumberSetting(getShellOverride("LOOP_DETECTION_WINDOW"), fileConfig.loopDetectionWindow, 6),
+        maxToolOutputChars: getNumberSetting(getShellOverride("MAX_TOOL_OUTPUT_CHARS"), fileConfig.maxToolOutputChars, 8000),
+        openAiBaseUrl,
+        ...(openAiApiKey ? { openAiApiKey } : {}),
     };
 }
 /* ------------------------------------------------------------------ */
@@ -94,8 +137,9 @@ export async function loadTasks(tasksDir, args) {
 /* ------------------------------------------------------------------ */
 async function main() {
     const args = parseArgs(process.argv.slice(2));
-    const config = buildConfig();
-    const tasksDir = path.resolve(process.cwd(), "benchmarks", "tasks");
+    const repoRoot = process.cwd();
+    const config = buildConfig({ repoRoot });
+    const tasksDir = path.resolve(repoRoot, "benchmarks", "tasks");
     console.log(`Benchmark runner starting...`);
     console.log(`  Provider: ${config.modelProvider}`);
     console.log(`  Model: ${config.model}`);
@@ -104,19 +148,20 @@ async function main() {
     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,
+        repoRoot,
+        isolateWorkspace: true,
+        createToolset: async (taskConfig) => {
+            const projectIndex = await buildProjectIndex(taskConfig.workspaceRoot);
+            const toolRegistry = createToolRegistry(taskConfig, projectIndex);
+            return {
+                tools: toolRegistry.getDefinitions(),
+                projectIndex,
+            };
+        },
         onTaskComplete: (taskId, trace) => {
             const dur = (trace.durationMs / 1000).toFixed(1);
             console.log(`  [done] ${taskId} (${dur}s, ${trace.toolCalls.length} tool calls)`);

package/dist/src/agent/config.js

@@ -1,4 +1,4 @@
-import { access, mkdir, readFile, writeFile } from "node:fs/promises";
+import { mkdir, readFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import process from "node:process";
@@ -10,7 +10,7 @@ export const MINICODE_HOME = path.join(os.homedir(), ".minicode");
  */
 export function formatConfigForDisplay(config) {
     const lines = [
-        "configHome: " + MINICODE_HOME + " (.env, agent.config.json)",
+        "configHome: " + MINICODE_HOME + " (.env)",
         "workspaceRoot: " + config.workspaceRoot,
         "modelProvider: " + config.modelProvider,
         "model: " + config.model,
@@ -46,9 +46,14 @@ export function formatConfigForDisplay(config) {
  */
 export function getConfigMissing(config) {
     const missing = [];
+    const isOpenRouter = config.modelProvider === "openai-compatible" &&
+        config.openAiBaseUrl.includes("openrouter");
     if (!config.model) {
         missing.push("MODEL is not set");
     }
+    if (isOpenRouter && !config.openAiApiKey?.trim()) {
+        missing.push("OPENROUTER_API_KEY is not set");
+    }
     if (config.modelProvider === "anthropic" && !process.env.ANTHROPIC_API_KEY) {
         missing.push("ANTHROPIC_API_KEY is not set");
     }
@@ -63,8 +68,8 @@ export function getConfigSetupMessage(config) {
         "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.`,
+        "Set these in ~/.minicode/.env or as environment variables.",
+        "Editable runtime defaults set through the UI or /config are saved back to ~/.minicode/.env.",
         "",
         "Example ~/.minicode/.env for a local model:",
         "  MODEL_PROVIDER=openai-compatible",
@@ -117,20 +122,6 @@ function parseBoolean(value, fallback) {
     }
     return fallback;
 }
-export async function loadConfigFile(configPath) {
-    try {
-        await access(configPath);
-    }
-    catch {
-        return {};
-    }
-    const file = await readFile(configPath, "utf8");
-    const parsed = JSON.parse(file);
-    if (!parsed || typeof parsed !== "object") {
-        return {};
-    }
-    return parsed;
-}
 async function loadDotenvFile(envPath) {
     try {
         const file = await readFile(envPath, "utf8");
@@ -188,6 +179,24 @@ function parseUserDenylist(patterns) {
     }
     return denylist;
 }
+function parseCommandDenylistEnv(value) {
+    if (!value?.trim()) {
+        return [];
+    }
+    const trimmed = value.trim();
+    if (trimmed.startsWith("[")) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (Array.isArray(parsed) && parsed.every((item) => typeof item === "string")) {
+                return parseUserDenylist(parsed);
+            }
+        }
+        catch {
+            return [];
+        }
+    }
+    return parseUserDenylist(trimmed.split(",").map((pattern) => pattern.trim()).filter(Boolean));
+}
 function parseModelProvider(value) {
     const normalized = value?.trim().toLowerCase();
     if (normalized === "openai-compatible" ||
@@ -198,74 +207,50 @@ function parseModelProvider(value) {
     }
     return "anthropic";
 }
-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 rawWorkspaceRoot = env.WORKSPACE_ROOT ?? cwd;
     const workspaceRoot = path.resolve(cwd, rawWorkspaceRoot);
     const commandDenylist = [
         ...DEFAULT_COMMAND_DENYLIST,
-        ...parseUserDenylist(fileConfig.commandDenylist),
+        ...parseCommandDenylistEnv(env.COMMAND_DENYLIST),
     ];
-    const rawBaseUrl = env.OPENAI_BASE_URL ??
-        fileConfig.openAiBaseUrl ??
-        "http://localhost:1234/v1";
+    const rawBaseUrl = env.OPENAI_BASE_URL ?? "http://localhost:1234/v1";
     const isOpenRouter = rawBaseUrl.includes("openrouter");
     const openAiApiKey = isOpenRouter
-        ? (env.OPENROUTER_API_KEY ??
-            env.OPENAI_API_KEY ??
-            fileConfig.openAiApiKey)
-        : (env.OPENAI_API_KEY ?? fileConfig.openAiApiKey);
+        ? (env.OPENROUTER_API_KEY ?? env.OPENAI_API_KEY)
+        : env.OPENAI_API_KEY;
     return {
-        modelProvider: parseModelProvider(env.MODEL_PROVIDER ?? fileConfig.modelProvider ?? "openai-compatible"),
-        model: env.MODEL ??
-            fileConfig.model ??
-            "",
-        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),
+        modelProvider: parseModelProvider(env.MODEL_PROVIDER ?? "openai-compatible"),
+        model: env.MODEL ?? "",
+        maxSteps: parseNumber(env.MAX_STEPS, 50),
+        maxTokens: parseNumber(env.MAX_TOKENS, 4096),
+        maxContextTokens: parseNumber(env.MAX_CONTEXT_TOKENS, 32_000),
         workspaceRoot,
-        commandTimeoutMs: parseNumber(env.COMMAND_TIMEOUT_MS, fileConfig.commandTimeout ?? 30_000),
-        maxFileSizeBytes: parseNumber(env.MAX_FILE_SIZE_BYTES, fileConfig.maxFileSizeBytes ?? 1_000_000),
+        commandTimeoutMs: parseNumber(env.COMMAND_TIMEOUT_MS, 30_000),
+        maxFileSizeBytes: parseNumber(env.MAX_FILE_SIZE_BYTES, 1_000_000),
         commandDenylist,
-        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),
+        confirmDestructive: parseBoolean(env.CONFIRM_DESTRUCTIVE, true),
+        keepRecentMessages: parseNumber(env.KEEP_RECENT_MESSAGES, 12),
+        loopDetectionWindow: parseNumber(env.LOOP_DETECTION_WINDOW, 6),
+        maxToolOutputChars: parseNumber(env.MAX_TOOL_OUTPUT_CHARS, 8_000),
         openAiBaseUrl: rawBaseUrl,
         ...(openAiApiKey !== undefined ? { openAiApiKey } : {}),
-        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 }
+        enableFileReadDedup: parseBoolean(env.ENABLE_FILE_READ_DEDUP, true),
+        enableAdaptiveKeepRecent: parseBoolean(env.ENABLE_ADAPTIVE_KEEP_RECENT, true),
+        enableToolOutputTruncation: parseBoolean(env.ENABLE_TOOL_OUTPUT_TRUNCATION, true),
+        compactionThreshold: parseNumber(env.COMPACTION_THRESHOLD, 0.8),
+        ...(env.COMPACTION_MODEL
+            ? { compactionModel: env.COMPACTION_MODEL }
             : {}),
-        enableDynamicPrompt: parseBoolean(env.ENABLE_DYNAMIC_PROMPT, fileConfig.enableDynamicPrompt ?? true),
+        enableDynamicPrompt: parseBoolean(env.ENABLE_DYNAMIC_PROMPT, true),
         ...(() => {
-            const effort = parseReasoningEffort(env.REASONING_EFFORT ?? fileConfig.reasoningEffort);
+            const effort = parseReasoningEffort(env.REASONING_EFFORT);
             return effort ? { reasoningEffort: effort } : {};
         })(),
     };