@sean.holung/minicode 0.3.4 → 0.3.6

package/dist/tests/config-integration.test.js

@@ -1,8 +1,8 @@
 /**
  * Integration tests for the config system.
  *
- * Tests the full config resolution chain: agent.config.json → ~/.minicode/.env → shell env vars,
- * getConfigSetupMessage / getConfigMissing, ensureMinicodeHome, the /api/status needsSetup flag,
+ * Tests the current config resolution chain: ~/.minicode/.env → shell env vars,
+ * getConfigSetupMessage / getConfigMissing, minicode home bootstrapping, the /api/status needsSetup flag,
  * and AgentBridge graceful degradation when model client cannot initialize.
  */
 import assert from "node:assert/strict";
@@ -11,7 +11,7 @@ import { access, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { afterEach, describe, test } from "node:test";
-import { loadAgentConfig, resolveConfigEnv, getConfigSetupMessage, getConfigMissing, loadConfigFile, } from "../src/agent/config.js";
+import { loadAgentConfig, resolveConfigEnv, getConfigSetupMessage, getConfigMissing, } from "../src/agent/config.js";
 import { buildStructuredConfigPayload } from "../src/agent/editable-config.js";
 import { createRequestHandler } from "../src/serve/server.js";
 import { AgentBridge } from "../src/serve/agent-bridge.js";
@@ -25,14 +25,46 @@ afterEach(async () => {
     await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })));
 });
 /** Create an isolated minicode home directory with optional config and .env files. */
+function serializeConfigEnv(config) {
+    const lines = [];
+    const push = (key, value) => {
+        if (value === undefined || value === null) {
+            return;
+        }
+        lines.push(`${key}=${String(value)}`);
+    };
+    push("MODEL_PROVIDER", config.modelProvider);
+    push("MODEL", config.model);
+    push("MAX_STEPS", config.maxSteps);
+    push("MAX_TOKENS", config.maxTokens);
+    push("MAX_CONTEXT_TOKENS", config.maxContextTokens);
+    push("WORKSPACE_ROOT", config.workspaceRoot);
+    push("COMMAND_TIMEOUT_MS", config.commandTimeout);
+    if (Array.isArray(config.commandDenylist)) {
+        lines.push(`COMMAND_DENYLIST=${JSON.stringify(config.commandDenylist)}`);
+    }
+    push("CONFIRM_DESTRUCTIVE", config.confirmDestructive);
+    push("MAX_FILE_SIZE_BYTES", config.maxFileSizeBytes);
+    push("KEEP_RECENT_MESSAGES", config.keepRecentMessages);
+    push("LOOP_DETECTION_WINDOW", config.loopDetectionWindow);
+    push("MAX_TOOL_OUTPUT_CHARS", config.maxToolOutputChars);
+    push("OPENAI_BASE_URL", config.openAiBaseUrl);
+    push("OPENAI_API_KEY", config.openAiApiKey);
+    push("ENABLE_FILE_READ_DEDUP", config.enableFileReadDedup);
+    push("ENABLE_ADAPTIVE_KEEP_RECENT", config.enableAdaptiveKeepRecent);
+    push("ENABLE_TOOL_OUTPUT_TRUNCATION", config.enableToolOutputTruncation);
+    push("COMPACTION_THRESHOLD", config.compactionThreshold);
+    push("COMPACTION_MODEL", config.compactionModel);
+    push("REASONING_EFFORT", config.reasoningEffort);
+    push("ENABLE_DYNAMIC_PROMPT", config.enableDynamicPrompt);
+    return lines.length > 0 ? `${lines.join("\n")}\n` : "";
+}
 async function createTestHome(options = {}) {
     const home = await mkdtemp(path.join(os.tmpdir(), "minicode-integ-"));
     tempDirs.push(home);
-    if (options.config) {
-        await writeFile(path.join(home, "agent.config.json"), JSON.stringify(options.config, null, 2) + "\n", "utf8");
-    }
-    if (options.dotenv !== undefined) {
-        await writeFile(path.join(home, ".env"), options.dotenv, "utf8");
+    const envContent = `${options.config ? serializeConfigEnv(options.config) : ""}${options.dotenv ?? ""}`;
+    if (envContent.length > 0) {
+        await writeFile(path.join(home, ".env"), envContent, "utf8");
     }
     return home;
 }
@@ -102,27 +134,25 @@ function startServer(bridge, options = {}) {
     });
 }
 // ═══════════════════════════════════════════════════════════════════
-// Config file loading
+// Home env loading via loadAgentConfig
 // ═══════════════════════════════════════════════════════════════════
-describe("loadConfigFile", () => {
-    test("returns empty object when file does not exist", async () => {
-        const result = await loadConfigFile("/tmp/nonexistent-minicode-test/config.json");
-        assert.deepEqual(result, {});
-    });
-    test("parses valid JSON config file", async () => {
+describe("loadAgentConfig home env", () => {
+    test("uses ~/.minicode/.env values when present", async () => {
         const home = await createTestHome({
-            config: { model: "test-model", maxSteps: 25 },
+            dotenv: "MODEL=test-model\nMAX_STEPS=25\n",
+        });
+        await withEnv({ MODEL: undefined, MAX_STEPS: undefined }, async () => {
+            const config = await loadAgentConfig("/tmp", { minicodeHome: home });
+            assert.equal(config.model, "test-model");
+            assert.equal(config.maxSteps, 25);
         });
-        const result = await loadConfigFile(path.join(home, "agent.config.json"));
-        assert.equal(result.model, "test-model");
-        assert.equal(result.maxSteps, 25);
     });
 });
 // ═══════════════════════════════════════════════════════════════════
-// ensureMinicodeHome
+// minicode home bootstrapping
 // ═══════════════════════════════════════════════════════════════════
 describe("ensureMinicodeHome (via loadAgentConfig)", () => {
-    test("creates directory and starter config when home does not exist", async () => {
+    test("creates the minicode home directory when it does not exist", async () => {
         const base = await mkdtemp(path.join(os.tmpdir(), "minicode-integ-"));
         tempDirs.push(base);
         const minicodeHome = path.join(base, "fresh-home");
@@ -131,22 +161,18 @@ describe("ensureMinicodeHome (via loadAgentConfig)", () => {
         });
         // Directory should exist
         await access(minicodeHome);
-        // Starter config should have been written
-        const content = JSON.parse(await readFile(path.join(minicodeHome, "agent.config.json"), "utf8"));
-        assert.equal(content.model, "");
-        assert.equal(content.modelProvider, "openai-compatible");
-        assert.equal(content.openAiBaseUrl, "http://localhost:1234/v1");
+        await assert.rejects(access(path.join(minicodeHome, "agent.config.json")));
     });
-    test("does not overwrite existing config", async () => {
+    test("does not overwrite an existing home .env file", async () => {
         const home = await createTestHome({
-            config: { model: "my-model", maxSteps: 99 },
+            dotenv: "MODEL=my-model\nMAX_STEPS=99\n",
         });
         await withEnv({ MODEL: undefined }, async () => {
             await loadAgentConfig("/tmp", { minicodeHome: home });
         });
-        const content = JSON.parse(await readFile(path.join(home, "agent.config.json"), "utf8"));
-        assert.equal(content.model, "my-model");
-        assert.equal(content.maxSteps, 99);
+        const content = await readFile(path.join(home, ".env"), "utf8");
+        assert.match(content, /^MODEL=my-model$/m);
+        assert.match(content, /^MAX_STEPS=99$/m);
     });
 });
 // ═══════════════════════════════════════════════════════════════════
@@ -207,7 +233,7 @@ describe("resolveConfigEnv precedence", () => {
 // loadAgentConfig — full precedence chain
 // ═══════════════════════════════════════════════════════════════════
 describe("loadAgentConfig precedence", () => {
-    test("config file value is used when no env override exists", async () => {
+    test("home .env value is used when no shell override exists", async () => {
         const home = await createTestHome({
             config: { model: "config-model", maxSteps: 42 },
         });
@@ -217,7 +243,7 @@ describe("loadAgentConfig precedence", () => {
             assert.equal(config.maxSteps, 42);
         });
     });
-    test("home .env overrides config file", async () => {
+    test("later home .env entries override earlier persisted values", async () => {
         const home = await createTestHome({
             config: { model: "config-model", maxSteps: 42 },
             dotenv: "MODEL=dotenv-model\n",
@@ -225,11 +251,10 @@ describe("loadAgentConfig precedence", () => {
         await withEnv({ MODEL: undefined }, async () => {
             const config = await loadAgentConfig("/tmp", { minicodeHome: home });
             assert.equal(config.model, "dotenv-model");
-            // maxSteps not in .env, so config file value is used
             assert.equal(config.maxSteps, 42);
         });
     });
-    test("shell env overrides both config file and home .env", async () => {
+    test("shell env overrides home .env", async () => {
         const home = await createTestHome({
             config: { model: "config-model", maxSteps: 42 },
             dotenv: "MODEL=dotenv-model\nMAX_STEPS=77\n",
@@ -285,18 +310,13 @@ describe("loadAgentConfig precedence", () => {
             assert.equal(config.openAiApiKey, "sk-shell-key");
         });
     });
-    test("OPENAI_API_KEY from config file is used as last resort", async () => {
+    test("OPENAI_API_KEY is unset when not provided in env", async () => {
         const home = await createTestHome({
-            config: {
-                modelProvider: "openai-compatible",
-                model: "test-model",
-                openAiBaseUrl: "http://localhost:1234/v1",
-                openAiApiKey: "sk-file-key",
-            },
+            dotenv: "MODEL_PROVIDER=openai-compatible\nMODEL=test-model\nOPENAI_BASE_URL=http://localhost:1234/v1\n",
         });
         await withEnv({ OPENAI_API_KEY: undefined, MODEL: undefined, MODEL_PROVIDER: undefined }, async () => {
             const config = await loadAgentConfig("/tmp", { minicodeHome: home });
-            assert.equal(config.openAiApiKey, "sk-file-key");
+            assert.equal(config.openAiApiKey, undefined);
         });
     });
     test("OpenRouter base URL resolves OPENROUTER_API_KEY with fallback to OPENAI_API_KEY", async () => {
@@ -412,6 +432,26 @@ describe("getConfigMissing and getConfigSetupMessage", () => {
             assert.deepEqual(getConfigMissing(config), []);
         });
     });
+    test("returns OPENROUTER_API_KEY missing for OpenRouter without a key", () => {
+        const config = {
+            ...createTestAgentConfig("/tmp"),
+            modelProvider: "openai-compatible",
+            model: "google/gemini-2.5-flash",
+            openAiBaseUrl: "https://openrouter.ai/api/v1",
+        };
+        const missing = getConfigMissing(config);
+        assert.ok(missing.some((m) => m.includes("OPENROUTER_API_KEY")));
+    });
+    test("does not require OPENROUTER_API_KEY when OpenRouter key is present in config", () => {
+        const config = {
+            ...createTestAgentConfig("/tmp"),
+            modelProvider: "openai-compatible",
+            model: "google/gemini-2.5-flash",
+            openAiBaseUrl: "https://openrouter.ai/api/v1",
+            openAiApiKey: "sk-or-v1-test",
+        };
+        assert.deepEqual(getConfigMissing(config), []);
+    });
     test("can return multiple missing items simultaneously", async () => {
         await withEnv({ ANTHROPIC_API_KEY: undefined }, async () => {
             const config = {
@@ -430,7 +470,7 @@ describe("getConfigMissing and getConfigSetupMessage", () => {
         const message = getConfigSetupMessage(config);
         assert.ok(message.includes("MODEL is not set"));
         assert.ok(message.includes("~/.minicode/.env"));
-        assert.ok(message.includes("agent.config.json"));
+        assert.ok(message.includes("saved back to ~/.minicode/.env"));
     });
 });
 // ═══════════════════════════════════════════════════════════════════
@@ -504,6 +544,25 @@ describe("loadAgentConfig → getConfigMissing integration", () => {
             assert.ok(missing.some((m) => m.includes("ANTHROPIC_API_KEY")));
         });
     });
+    test("OpenRouter provider without API key reports missing", async () => {
+        const home = await createTestHome({
+            config: {
+                modelProvider: "openai-compatible",
+                model: "google/gemini-2.5-flash",
+                openAiBaseUrl: "https://openrouter.ai/api/v1",
+            },
+        });
+        await withEnv({
+            OPENROUTER_API_KEY: undefined,
+            OPENAI_API_KEY: undefined,
+            MODEL: undefined,
+            MODEL_PROVIDER: undefined,
+        }, async () => {
+            const config = await loadAgentConfig("/tmp", { minicodeHome: home });
+            const missing = getConfigMissing(config);
+            assert.ok(missing.some((m) => m.includes("OPENROUTER_API_KEY")));
+        });
+    });
 });
 // ═══════════════════════════════════════════════════════════════════
 // /api/status endpoint — needsSetup and missing fields
@@ -551,6 +610,20 @@ describe("/api/status needsSetup", () => {
             assert.ok(body.missing.some((m) => m.includes("ANTHROPIC_API_KEY")));
         });
     });
+    test("returns needsSetup: true for OpenRouter without API key", async () => {
+        const config = {
+            ...createTestAgentConfig("/tmp"),
+            modelProvider: "openai-compatible",
+            model: "google/gemini-2.5-flash",
+            openAiBaseUrl: "https://openrouter.ai/api/v1",
+        };
+        const bridge = new ConfigurableBridge(config);
+        const base = await startServer(bridge);
+        const res = await fetch(`${base}/api/status`);
+        const body = await res.json();
+        assert.equal(body.needsSetup, true);
+        assert.ok(body.missing.some((m) => m.includes("OPENROUTER_API_KEY")));
+    });
     test("status endpoint includes model and provider info", async () => {
         const config = {
             ...createTestAgentConfig("/tmp"),
@@ -600,7 +673,7 @@ describe("buildStructuredConfigPayload env source tracking", () => {
             assert.equal(modelEntry.envSource, "process");
         });
     });
-    test("reports env override from home-dotenv", async () => {
+    test("treats ~/.minicode/.env as persisted settings rather than an override", async () => {
         const home = await createTestHome({
             config: { model: "file-model" },
             dotenv: "MAX_STEPS=88\n",
@@ -609,13 +682,14 @@ describe("buildStructuredConfigPayload env source tracking", () => {
             const config = await loadAgentConfig("/tmp", { minicodeHome: home });
             const payload = await buildStructuredConfigPayload(config, home);
             const maxStepsEntry = payload.entries.find((e) => e.key === "maxSteps");
-            assert.equal(maxStepsEntry.overriddenByEnv, true);
-            assert.equal(maxStepsEntry.envValue, "88");
-            assert.equal(maxStepsEntry.envSource, "home-dotenv");
-            assert.equal(maxStepsEntry.envSourcePath, path.join(home, ".env"));
+            assert.equal(maxStepsEntry.overriddenByEnv, false);
+            assert.equal(maxStepsEntry.persistedValue, 88);
+            assert.equal(maxStepsEntry.envValue, null);
+            assert.equal(maxStepsEntry.envSource, null);
+            assert.equal(maxStepsEntry.envSourcePath, null);
         });
     });
-    test("reports no env override when value only in config file", async () => {
+    test("shows home .env values as both effective and persisted", async () => {
         const home = await createTestHome({
             config: { maxSteps: 42 },
         });
@@ -624,6 +698,7 @@ describe("buildStructuredConfigPayload env source tracking", () => {
             const payload = await buildStructuredConfigPayload(config, home);
             const maxStepsEntry = payload.entries.find((e) => e.key === "maxSteps");
             assert.equal(maxStepsEntry.overriddenByEnv, false);
+            assert.equal(maxStepsEntry.effectiveValue, 42);
             assert.equal(maxStepsEntry.persistedValue, 42);
         });
     });
@@ -643,7 +718,7 @@ describe("buildStructuredConfigPayload env source tracking", () => {
 // Realistic user scenario tests
 // ═══════════════════════════════════════════════════════════════════
 describe("realistic user scenarios", () => {
-    test("OpenRouter setup: config file + shell OPENAI_API_KEY → no setup needed", async () => {
+    test("OpenRouter setup: home .env + shell OPENAI_API_KEY → no setup needed", async () => {
         // User has modelProvider and openAiBaseUrl in config, OPENAI_API_KEY in shell
         const home = await createTestHome({
             config: {
@@ -695,7 +770,7 @@ describe("realistic user scenarios", () => {
             assert.ok(missing[0].includes("MODEL"));
         });
     });
-    test("local LM Studio setup: only config file, no env vars needed", async () => {
+    test("local LM Studio setup: only home .env, no shell env vars needed", async () => {
         const home = await createTestHome({
             config: {
                 modelProvider: "openai-compatible",
@@ -733,15 +808,14 @@ describe("realistic user scenarios", () => {
             assert.deepEqual(getConfigMissing(config), []);
         });
     });
-    test("fresh install: auto-created config triggers setup overlay", async () => {
+    test("fresh install: missing model still triggers setup overlay", async () => {
         const base = await mkdtemp(path.join(os.tmpdir(), "minicode-integ-"));
         tempDirs.push(base);
         const minicodeHome = path.join(base, "new-home");
         await withEnv({ MODEL: undefined, MODEL_PROVIDER: undefined }, async () => {
             const config = await loadAgentConfig("/tmp", { minicodeHome });
-            // Should have auto-created the directory and starter config
-            const fileContent = await readFile(path.join(minicodeHome, "agent.config.json"), "utf8");
-            assert.ok(fileContent.includes('"model": ""'));
+            await access(minicodeHome);
+            await assert.rejects(access(path.join(minicodeHome, "agent.config.json")));
             // Empty model → needs setup
             assert.equal(config.model, "");
             const missing = getConfigMissing(config);

package/dist/tests/config-slash-command.test.js

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { access, mkdtemp, readFile, rm } from "node:fs/promises";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { afterEach, test } from "node:test";
@@ -18,14 +18,15 @@ test("setPersistedConfigValue writes mapped keys and unset removes empty config
         key: "commandTimeoutMs",
         rawValue: "45000",
     });
-    assert.equal(setResult.path, path.join(home, "agent.config.json"));
-    const file = JSON.parse(await readFile(setResult.path, "utf8"));
-    assert.equal(file.commandTimeout, 45000);
+    assert.equal(setResult.path, path.join(home, ".env"));
+    const file = await readFile(setResult.path, "utf8");
+    assert.match(file, /^COMMAND_TIMEOUT_MS=45000$/m);
     await unsetPersistedConfigValue({
         minicodeHome: home,
         key: "commandTimeoutMs",
     });
-    await assert.rejects(access(setResult.path));
+    const updated = await readFile(setResult.path, "utf8");
+    assert.doesNotMatch(updated, /^COMMAND_TIMEOUT_MS=/m);
 });
 test("handleConfigSlashCommand persists config and reports env overrides", async () => {
     const home = await mkdtemp(path.join(os.tmpdir(), "minicode-config-"));
@@ -41,9 +42,9 @@ test("handleConfigSlashCommand persists config and reports env overrides", async
         });
         assert.equal(result.handled, true);
         assert.match(result.message ?? "", /Saved config: maxSteps = 64/);
-        assert.match(result.message ?? "", /MAX_STEPS is currently set/);
-        const persisted = JSON.parse(await readFile(path.join(home, "agent.config.json"), "utf8"));
-        assert.equal(persisted.maxSteps, 64);
+        assert.match(result.message ?? "", /MAX_STEPS is currently exported in your shell/);
+        const persisted = await readFile(path.join(home, ".env"), "utf8");
+        assert.match(persisted, /^MAX_STEPS=64$/m);
     }
     finally {
         if (previous === undefined) {
@@ -76,8 +77,8 @@ test("handleConfigSlashCommand reports config layers with /config get", async ()
         });
         assert.equal(getResult.handled, true);
         assert.match(getResult.message ?? "", /effective: openai-compatible/);
-        assert.match(getResult.message ?? "", /config file: openai-compatible/);
-        assert.match(getResult.message ?? "", /env override \(MODEL_PROVIDER\): openai-compatible/);
+        assert.match(getResult.message ?? "", /saved in ~\/\.minicode\/\.env: openai-compatible/);
+        assert.match(getResult.message ?? "", /exported env override \(MODEL_PROVIDER\): openai-compatible/);
     }
     finally {
         if (previous === undefined) {
@@ -102,5 +103,5 @@ test("handleConfigSlashCommand rejects non-editable keys and keeps secrets env-o
 });
 test("getGlobalConfigPath resolves to minicode home", () => {
     const home = "/tmp/example-home";
-    assert.equal(getGlobalConfigPath(home), path.join(home, "agent.config.json"));
+    assert.equal(getGlobalConfigPath(home), path.join(home, ".env"));
 });

package/dist/tests/config.test.js

@@ -47,8 +47,7 @@ test("loadAgentConfig uses global config and env vars with correct precedence",
     tempDirs.push(base);
     const minicodeHome = path.join(base, "home");
     await mkdir(minicodeHome, { recursive: true });
-    await writeFile(path.join(minicodeHome, "agent.config.json"), JSON.stringify({ model: "global-model", maxSteps: 33 }, null, 2) + "\n", "utf8");
-    await writeFile(path.join(minicodeHome, ".env"), "MODEL=home-env-model\n", "utf8");
+    await writeFile(path.join(minicodeHome, ".env"), "MODEL=home-env-model\nMAX_STEPS=33\n", "utf8");
     const previousMaxSteps = process.env.MAX_STEPS;
     const previousModel = process.env.MODEL;
     try {
@@ -56,9 +55,7 @@ test("loadAgentConfig uses global config and env vars with correct precedence",
         process.env.MAX_STEPS = "120";
         delete process.env.MODEL;
         const config = await loadAgentConfig("/tmp", { minicodeHome });
-        // MODEL from ~/.minicode/.env (no shell override)
         assert.equal(config.model, "home-env-model");
-        // MAX_STEPS from shell env (overrides config file value of 33)
         assert.equal(config.maxSteps, 120);
     }
     finally {
@@ -76,3 +73,14 @@ test("loadAgentConfig uses global config and env vars with correct precedence",
         }
     }
 });
+test("loadAgentConfig appends COMMAND_DENYLIST patterns from env", async () => {
+    const base = await mkdtemp(path.join(os.tmpdir(), "minicode-config-test-"));
+    tempDirs.push(base);
+    const minicodeHome = path.join(base, "home");
+    await mkdir(minicodeHome, { recursive: true });
+    await writeFile(path.join(minicodeHome, ".env"), 'MODEL=test-model\nCOMMAND_DENYLIST=["custom-danger","^wipe-db$"]\n', "utf8");
+    const config = await loadAgentConfig("/tmp", { minicodeHome });
+    const serialized = config.commandDenylist.map((pattern) => pattern.source);
+    assert.ok(serialized.includes("custom-danger"));
+    assert.ok(serialized.includes("^wipe-db$"));
+});

package/dist/tests/editable-config.test.js

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { access, mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { afterEach, test } from "node:test";
@@ -47,7 +47,7 @@ test("buildStructuredConfigPayload reports effective values and env overrides",
             maxSteps: 120,
             model: "global-model",
         }, home);
-        assert.equal(payload.configPath, path.join(home, "agent.config.json"));
+        assert.equal(payload.configPath, path.join(home, ".env"));
         const maxSteps = payload.entries.find((entry) => entry.key === "maxSteps");
         assert.equal(maxSteps?.effectiveValue, 120);
         assert.equal(maxSteps?.persistedValue, 77);
@@ -73,13 +73,14 @@ test("buildStructuredConfigPayload reports home dotenv env source", async () =>
             maxSteps: 88,
         }, home);
         const maxSteps = payload.entries.find((entry) => entry.key === "maxSteps");
-        assert.equal(maxSteps?.envValue, "88");
-        assert.equal(maxSteps?.envSource, "home-dotenv");
-        assert.equal(maxSteps?.envSourcePath, path.join(home, ".env"));
-        assert.equal(maxSteps?.overriddenByEnv, true);
+        assert.equal(maxSteps?.persistedValue, 88);
+        assert.equal(maxSteps?.envValue, null);
+        assert.equal(maxSteps?.envSource, null);
+        assert.equal(maxSteps?.envSourcePath, null);
+        assert.equal(maxSteps?.overriddenByEnv, false);
     });
 });
-test("applyPersistedConfigUpdates writes global config and removes files when everything is unset", async () => {
+test("applyPersistedConfigUpdates writes ~/.minicode/.env and removes keys when unset", async () => {
     const home = await mkdtemp(path.join(os.tmpdir(), "minicode-editable-config-"));
     tempDirs.push(home);
     const result = await applyPersistedConfigUpdates({
@@ -94,10 +95,10 @@ test("applyPersistedConfigUpdates writes global config and removes files when ev
         { key: "keepRecentMessages", value: 18 },
         { key: "enableFileReadDedup", value: false },
     ]);
-    const configPath = path.join(home, "agent.config.json");
-    const persisted = JSON.parse(await readFile(configPath, "utf8"));
-    assert.equal(persisted.keepRecentMessages, 18);
-    assert.equal(persisted.enableFileReadDedup, false);
+    const envPath = path.join(home, ".env");
+    let persisted = await readFile(envPath, "utf8");
+    assert.match(persisted, /^KEEP_RECENT_MESSAGES=18$/m);
+    assert.match(persisted, /^ENABLE_FILE_READ_DEDUP=false$/m);
     await applyPersistedConfigUpdates({
         minicodeHome: home,
         updates: {
@@ -105,5 +106,7 @@ test("applyPersistedConfigUpdates writes global config and removes files when ev
             enableFileReadDedup: null,
         },
     });
-    await assert.rejects(access(configPath));
+    persisted = await readFile(envPath, "utf8");
+    assert.doesNotMatch(persisted, /^KEEP_RECENT_MESSAGES=/m);
+    assert.doesNotMatch(persisted, /^ENABLE_FILE_READ_DEDUP=/m);
 });

package/dist/tests/file-tools.test.js

@@ -3,7 +3,7 @@ import { mkdtemp, readFile, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import { test } from "node:test";
-import { createEditFileTool, createReadFileTool } from "@minicode/agent-sdk";
+import { createEditFileTool, createReadFileTool, createRunCommandTool, createWriteFileTool } from "@minicode/agent-sdk";
 import { buildProjectIndex } from "../src/indexer/project-index.js";
 import { createTestAgentConfig } from "./test-utils.js";
 async function createTempWorkspace() {
@@ -58,6 +58,39 @@ test("edit_file triggers reindex when projectIndex provided", async () => {
     const after = index.getSymbol("add");
     assert.ok(after?.signature.includes("c?: number"), "index should reflect edit");
 });
+test("write_file triggers reindex when projectIndex provided", async () => {
+    const workspaceRoot = await createTempWorkspace();
+    const index = await buildProjectIndex(workspaceRoot);
+    const writeTool = createWriteFileTool(createTestAgentConfig(workspaceRoot), { afterWrite: (relPath, content) => index.reindexFile(relPath, content) });
+    await writeTool.execute({
+        path: "src/util.ts",
+        content: `export function add(a: number, b: number): number {\n  return a + b;\n}\n`,
+    });
+    const added = index.getSymbol("add");
+    assert.ok(added?.signature.includes("a: number, b: number"), "index should reflect newly written file");
+});
+test("run_command refreshes index after shell-created file changes", async () => {
+    const workspaceRoot = await createTempWorkspace();
+    const index = await buildProjectIndex(workspaceRoot);
+    const runTool = createRunCommandTool(createTestAgentConfig(workspaceRoot), { afterCommand: async () => index.refreshFromWorkspace() });
+    await runTool.execute({
+        command: "mkdir -p src && cat <<'EOF' > src/util.ts\nexport function add(a: number, b: number): number {\n  return a + b;\n}\nEOF",
+    });
+    const added = index.getSymbol("add");
+    assert.ok(added?.signature.includes("a: number, b: number"), "index should reflect shell-created file");
+});
+test("run_command refresh removes deleted files from the index", async () => {
+    const workspaceRoot = await createTempWorkspace();
+    const { mkdir } = await import("node:fs/promises");
+    const filePath = path.join(workspaceRoot, "src", "util.ts");
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, `export function add(a: number, b: number): number {\n  return a + b;\n}\n`, "utf8");
+    const index = await buildProjectIndex(workspaceRoot);
+    assert.ok(index.getSymbol("add"));
+    const runTool = createRunCommandTool(createTestAgentConfig(workspaceRoot), { afterCommand: async () => index.refreshFromWorkspace() });
+    await runTool.execute({ command: "rm src/util.ts" });
+    assert.equal(index.getSymbol("add"), undefined, "deleted file should be removed from the index");
+});
 test("read_file supports negative offset and line limits", async () => {
     const workspaceRoot = await createTempWorkspace();
     const filePath = path.join(workspaceRoot, "lines.txt");

package/dist/tests/find-path.test.js

@@ -1,7 +1,9 @@
 import assert from "node:assert/strict";
 import path from "node:path";
 import { test } from "node:test";
-import { createProjectIndex } from "../src/indexer/project-index.js";
+import { mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { buildProjectIndex, createProjectIndex } from "../src/indexer/project-index.js";
 import { createFindPathTool } from "../src/tools/find-path.js";
 function makeSymbol(name, kind = "function") {
     return {
@@ -169,7 +171,6 @@ test("find_path tool reports no path when symbols are disconnected", async () =>
     assert.ok(result.includes("No path found"));
 });
 test("find_path tool works with real project index", async () => {
-    const { buildProjectIndex } = await import("../src/indexer/project-index.js");
     const root = path.resolve(import.meta.dirname, "..");
     const projectIndex = await buildProjectIndex(root);
     const tool = createFindPathTool(projectIndex);
@@ -181,3 +182,43 @@ test("find_path tool works with real project index", async () => {
     assert.ok(result.includes("# Path from createModelClient to AgentConfig"));
     assert.ok(result.includes("symbols"));
 });
+test("find_path returns disambiguation list for ambiguous bare target symbols", async () => {
+    const workspaceRoot = await mkdtemp(path.join(tmpdir(), "minicode-find-path-collisions-"));
+    await writeFile(path.join(workspaceRoot, "sample.ts"), `export type Review = { id: string };
+
+export class Review {
+  constructor(public id: string) {}
+}
+
+export function createReview(id: string) {
+  return new Review(id);
+}
+`, "utf8");
+    const projectIndex = await buildProjectIndex(workspaceRoot);
+    const tool = createFindPathTool(projectIndex);
+    const result = await tool.execute({ from: "createReview", to: "Review" });
+    assert.ok(result.includes('Symbol "Review" is ambiguous'));
+    assert.ok(result.includes("Review (type)"));
+    assert.ok(result.includes("Review (class)"));
+    assert.ok(result.includes("qualified: Review#type"));
+    assert.ok(result.includes("qualified: Review#class"));
+});
+test("find_path accepts qualified names for colliding symbols", async () => {
+    const workspaceRoot = await mkdtemp(path.join(tmpdir(), "minicode-find-path-qualified-"));
+    await writeFile(path.join(workspaceRoot, "sample.ts"), `export type Review = { id: string };
+
+export class Review {
+  constructor(public id: string) {}
+}
+
+export function createReview(id: string) {
+  return new Review(id);
+}
+`, "utf8");
+    const projectIndex = await buildProjectIndex(workspaceRoot);
+    const tool = createFindPathTool(projectIndex);
+    const result = await tool.execute({ from: "createReview", to: "Review#class" });
+    assert.ok(result.includes("# Path from createReview to Review (class)"));
+    assert.ok(result.includes("[function] createReview"));
+    assert.ok(result.includes("[class] Review (class)"));
+});