@sean.holung/minicode 0.3.4 → 0.3.6

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

@@ -1,6 +1,5 @@
-import { mkdir, rm, writeFile } from "node:fs/promises";
-import path from "node:path";
-import { loadConfigFile, MINICODE_HOME, resolveConfigEnv, } from "./config.js";
+import { MINICODE_HOME, resolveConfigEnv, } from "./config.js";
+import { getHomeEnvPath, loadHomeEnvValues, upsertHomeEnvValues } from "./home-env.js";
 const REASONING_VALUES = [
     "xhigh",
     "high",
@@ -12,7 +11,6 @@ const REASONING_VALUES = [
 export const EDITABLE_CONFIG_DEFINITIONS = [
     {
         key: "modelProvider",
-        fileKey: "modelProvider",
         envVar: "MODEL_PROVIDER",
         type: "enum",
         values: ["anthropic", "openai-compatible"],
@@ -20,119 +18,102 @@ export const EDITABLE_CONFIG_DEFINITIONS = [
     },
     {
         key: "model",
-        fileKey: "model",
         envVar: "MODEL",
         type: "string",
         description: "Default model id for new sessions",
     },
     {
         key: "maxSteps",
-        fileKey: "maxSteps",
         envVar: "MAX_STEPS",
         type: "number",
         description: "Turn call limit before the agent pauses and waits for another prompt",
     },
     {
         key: "maxTokens",
-        fileKey: "maxTokens",
         envVar: "MAX_TOKENS",
         type: "number",
         description: "Maximum completion tokens per model response",
     },
     {
         key: "maxContextTokens",
-        fileKey: "maxContextTokens",
         envVar: "MAX_CONTEXT_TOKENS",
         type: "number",
         description: "Estimated prompt-context budget before compaction",
     },
     {
         key: "commandTimeoutMs",
-        fileKey: "commandTimeout",
         envVar: "COMMAND_TIMEOUT_MS",
         type: "number",
         description: "Shell command timeout in milliseconds",
     },
     {
         key: "maxFileSizeBytes",
-        fileKey: "maxFileSizeBytes",
         envVar: "MAX_FILE_SIZE_BYTES",
         type: "number",
         description: "Maximum file size allowed for read/edit tools",
     },
     {
         key: "confirmDestructive",
-        fileKey: "confirmDestructive",
         envVar: "CONFIRM_DESTRUCTIVE",
         type: "boolean",
         description: "Whether destructive commands require confirmation",
     },
     {
         key: "keepRecentMessages",
-        fileKey: "keepRecentMessages",
         envVar: "KEEP_RECENT_MESSAGES",
         type: "number",
         description: "Recent messages preserved when trimming session history",
     },
     {
         key: "loopDetectionWindow",
-        fileKey: "loopDetectionWindow",
         envVar: "LOOP_DETECTION_WINDOW",
         type: "number",
         description: "Window size for repeated-tool-call loop detection",
     },
     {
         key: "maxToolOutputChars",
-        fileKey: "maxToolOutputChars",
         envVar: "MAX_TOOL_OUTPUT_CHARS",
         type: "number",
         description: "Maximum tool output retained before truncation",
     },
     {
         key: "openAiBaseUrl",
-        fileKey: "openAiBaseUrl",
         envVar: "OPENAI_BASE_URL",
         type: "string",
         description: "Base URL for OpenAI-compatible providers",
     },
     {
         key: "enableFileReadDedup",
-        fileKey: "enableFileReadDedup",
         envVar: "ENABLE_FILE_READ_DEDUP",
         type: "boolean",
         description: "Deduplicate repeated file reads in prompt context",
     },
     {
         key: "enableAdaptiveKeepRecent",
-        fileKey: "enableAdaptiveKeepRecent",
         envVar: "ENABLE_ADAPTIVE_KEEP_RECENT",
         type: "boolean",
         description: "Adjust recent-message retention based on context pressure",
     },
     {
         key: "enableToolOutputTruncation",
-        fileKey: "enableToolOutputTruncation",
         envVar: "ENABLE_TOOL_OUTPUT_TRUNCATION",
         type: "boolean",
         description: "Truncate oversized tool output before storing it in session history",
     },
     {
         key: "compactionThreshold",
-        fileKey: "compactionThreshold",
         envVar: "COMPACTION_THRESHOLD",
         type: "number",
         description: "Compaction threshold ratio used before a turn starts",
     },
     {
         key: "compactionModel",
-        fileKey: "compactionModel",
         envVar: "COMPACTION_MODEL",
         type: "string",
         description: "Optional model id used for LLM-based compaction",
     },
     {
         key: "reasoningEffort",
-        fileKey: "reasoningEffort",
         envVar: "REASONING_EFFORT",
         type: "enum",
         values: REASONING_VALUES,
@@ -140,7 +121,6 @@ export const EDITABLE_CONFIG_DEFINITIONS = [
     },
     {
         key: "enableDynamicPrompt",
-        fileKey: "enableDynamicPrompt",
         envVar: "ENABLE_DYNAMIC_PROMPT",
         type: "boolean",
         description: "Toggle project-aware dynamic prompt generation",
@@ -194,9 +174,6 @@ function normalizePersistedValue(value) {
     }
     return null;
 }
-function isEmptyConfigFile(config) {
-    return Object.keys(config).length === 0;
-}
 export function listEditableConfigDefinitions() {
     return EDITABLE_CONFIG_DEFINITIONS;
 }
@@ -223,10 +200,25 @@ export function formatPersistedConfigValue(value) {
     return String(value);
 }
 export function getGlobalConfigPath(minicodeHome = MINICODE_HOME) {
-    return path.join(minicodeHome, "agent.config.json");
+    return getHomeEnvPath(minicodeHome);
 }
 export async function loadPersistedConfig(minicodeHome = MINICODE_HOME) {
-    return loadConfigFile(getGlobalConfigPath(minicodeHome));
+    return loadHomeEnvValues(minicodeHome);
+}
+function readPersistedEnvValue(definition, persisted) {
+    const rawValue = persisted[definition.envVar];
+    if (rawValue === undefined) {
+        return null;
+    }
+    try {
+        return parseEditableValue(definition, rawValue);
+    }
+    catch {
+        return rawValue;
+    }
+}
+function serializeEditableValue(value) {
+    return String(value);
 }
 export async function buildStructuredConfigPayload(config, minicodeHome = MINICODE_HOME) {
     const configPath = getGlobalConfigPath(minicodeHome);
@@ -235,10 +227,11 @@ export async function buildStructuredConfigPayload(config, minicodeHome = MINICO
     return {
         configPath,
         entries: EDITABLE_CONFIG_DEFINITIONS.map((definition) => {
-            const envValue = env.values[definition.envVar];
-            const envSource = env.sources[definition.envVar] ?? null;
-            const envSourcePath = envSource === "home-dotenv"
-                ? env.homeEnvPath
+            const envSource = env.sources[definition.envVar] === "process"
+                ? "process"
+                : null;
+            const envValue = envSource === "process"
+                ? (env.values[definition.envVar] ?? null)
                 : null;
             return {
                 key: definition.key,
@@ -247,11 +240,11 @@ export async function buildStructuredConfigPayload(config, minicodeHome = MINICO
                 envVar: definition.envVar,
                 ...(definition.values ? { values: definition.values } : {}),
                 effectiveValue: normalizePersistedValue(config[definition.key]),
-                persistedValue: normalizePersistedValue(persisted[definition.fileKey]),
-                envValue: envValue ?? null,
+                persistedValue: readPersistedEnvValue(definition, persisted),
+                envValue,
                 envSource,
-                envSourcePath,
-                overriddenByEnv: envValue !== undefined,
+                envSourcePath: envSource === "process" ? null : null,
+                overriddenByEnv: envSource === "process",
             };
         }),
     };
@@ -260,26 +253,25 @@ export async function setPersistedConfigValue(options) {
     const minicodeHome = options.minicodeHome ?? MINICODE_HOME;
     const definition = getEditableConfigDefinition(options.key);
     const configPath = getGlobalConfigPath(minicodeHome);
-    const nextFile = await loadConfigFile(configPath);
     const storedValue = parseEditableValue(definition, options.rawValue);
-    nextFile[definition.fileKey] = storedValue;
-    await mkdir(path.dirname(configPath), { recursive: true });
-    await writeFile(configPath, JSON.stringify(nextFile, null, 2) + "\n", "utf8");
+    await upsertHomeEnvValues({
+        minicodeHome,
+        values: {
+            [definition.envVar]: serializeEditableValue(storedValue),
+        },
+    });
     return { path: configPath, storedValue };
 }
 export async function unsetPersistedConfigValue(options) {
     const minicodeHome = options.minicodeHome ?? MINICODE_HOME;
     const definition = getEditableConfigDefinition(options.key);
     const configPath = getGlobalConfigPath(minicodeHome);
-    const nextFile = await loadConfigFile(configPath);
-    delete nextFile[definition.fileKey];
-    if (isEmptyConfigFile(nextFile)) {
-        await rm(configPath, { force: true });
-    }
-    else {
-        await mkdir(path.dirname(configPath), { recursive: true });
-        await writeFile(configPath, JSON.stringify(nextFile, null, 2) + "\n", "utf8");
-    }
+    await upsertHomeEnvValues({
+        minicodeHome,
+        values: {
+            [definition.envVar]: null,
+        },
+    });
     return { path: configPath };
 }
 export async function applyPersistedConfigUpdates(options) {
@@ -291,22 +283,22 @@ export async function applyPersistedConfigUpdates(options) {
         return { key: rawKey, value };
     });
     const saved = [];
+    const envUpdates = {};
     for (const item of planned) {
+        const definition = getEditableConfigDefinition(item.key);
         if (item.value === null) {
-            await unsetPersistedConfigValue({
-                key: item.key,
-                minicodeHome,
-            });
+            envUpdates[definition.envVar] = null;
             saved.push({ key: item.key, value: null });
             continue;
         }
-        await setPersistedConfigValue({
-            key: item.key,
-            rawValue: String(item.value),
-            minicodeHome,
-        });
-        saved.push({ key: item.key, value: item.value });
+        const storedValue = parseEditableValue(definition, String(item.value));
+        envUpdates[definition.envVar] = serializeEditableValue(storedValue);
+        saved.push({ key: item.key, value: storedValue });
     }
+    await upsertHomeEnvValues({
+        minicodeHome,
+        values: envUpdates,
+    });
     return {
         path: getGlobalConfigPath(minicodeHome),
         saved,

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

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

package/dist/src/benchmark/runner.js

@@ -5,7 +5,17 @@
  * over tool-call instrumentation and trace capture.
  */
 import { execSync } from "node:child_process";
+import { cp, mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
 import { CodingAgent, Session, ToolRegistry, } from "@minicode/agent-sdk";
+const COPY_SKIP_NAMES = new Set([
+    ".git",
+    "node_modules",
+    "dist",
+    "build",
+    "coverage",
+]);
 function getGitCommitSha() {
     try {
         return execSync("git rev-parse HEAD", { encoding: "utf8" }).trim();
@@ -19,73 +29,146 @@ const STRUCTURAL_TOOLS = new Set([
     "find_references",
     "get_dependencies",
     "search_code_map",
+    "find_path",
 ]);
+function sanitizeTaskId(taskId) {
+    return taskId.replace(/[^a-z0-9-_]+/gi, "-");
+}
+function resolveSourceWorkspaceRoot(task, options) {
+    if (!task.workspaceRoot) {
+        return path.resolve(options.config.workspaceRoot);
+    }
+    const repoRoot = path.resolve(options.repoRoot ?? process.cwd());
+    return path.resolve(repoRoot, task.workspaceRoot);
+}
+function shouldCopyPath(src) {
+    const name = path.basename(src);
+    return !COPY_SKIP_NAMES.has(name);
+}
+async function prepareTaskWorkspace(task, options) {
+    const sourceWorkspaceRoot = resolveSourceWorkspaceRoot(task, options);
+    if (options.isolateWorkspace === false) {
+        return {
+            sourceWorkspaceRoot,
+            workspaceRoot: sourceWorkspaceRoot,
+            cleanup: async () => { },
+        };
+    }
+    const tempRoot = await mkdtemp(path.join(tmpdir(), "minicode-benchmark-"));
+    const isolatedWorkspaceRoot = path.join(tempRoot, sanitizeTaskId(task.id));
+    await cp(sourceWorkspaceRoot, isolatedWorkspaceRoot, {
+        recursive: true,
+        filter: shouldCopyPath,
+    });
+    return {
+        sourceWorkspaceRoot,
+        workspaceRoot: isolatedWorkspaceRoot,
+        cleanup: async () => {
+            await rm(tempRoot, { recursive: true, force: true });
+        },
+    };
+}
+function getTrackedSymbolNames(toolName, input) {
+    if (toolName === "find_path") {
+        const names = [input.from, input.to]
+            .filter((value) => typeof value === "string" && value.length > 0);
+        return [...new Set(names)];
+    }
+    const name = input.symbol ?? input.symbolName ?? input.name ?? input.query;
+    return typeof name === "string" && name.length > 0 ? [name] : [];
+}
+function trackStructuralFileReads(toolName, projectIndex, input, filesRead) {
+    if (!projectIndex || !STRUCTURAL_TOOLS.has(toolName)) {
+        return;
+    }
+    for (const symbolName of getTrackedSymbolNames(toolName, input)) {
+        const symbol = projectIndex.getSymbol(symbolName);
+        if (symbol) {
+            filesRead.add(symbol.filePath);
+        }
+    }
+}
 /**
  * Run a single benchmark task and return the captured trace.
  */
 export async function runBenchmarkTask(task, options) {
+    const workspace = await prepareTaskWorkspace(task, options);
     const captured = [];
     const filesRead = new Set();
     const symbolsQueried = new Set();
-    // Wrap each tool to capture calls
-    const instrumentedTools = options.tools.map((tool) => ({
-        ...tool,
-        execute: async (input) => {
-            const start = performance.now();
-            const output = await tool.execute(input);
-            const durationMs = performance.now() - start;
-            captured.push({
-                name: tool.name,
-                input,
-                output: output.length > 2000 ? output.slice(0, 2000) + "…[truncated]" : output,
-                durationMs,
-            });
-            // Track files read
-            if (tool.name === "read_file" || tool.name === "read_symbol") {
-                const filePath = input.path ?? input.file_path ?? input.filePath;
-                if (typeof filePath === "string")
-                    filesRead.add(filePath);
-            }
-            // Track symbol queries
-            if (STRUCTURAL_TOOLS.has(tool.name)) {
-                const sym = input.symbol ?? input.symbolName ?? input.name ?? input.query;
-                if (typeof sym === "string")
-                    symbolsQueried.add(sym);
-            }
-            return output;
-        },
-    }));
-    const registry = new ToolRegistry(instrumentedTools);
-    const session = new Session();
-    const agent = new CodingAgent({
-        config: options.config,
-        modelClient: options.modelClient,
-        toolRegistry: registry,
-        session,
-    });
-    const startedAt = new Date().toISOString();
-    const start = performance.now();
-    const { text, usage } = await agent.runTurn(task.prompt);
-    const durationMs = performance.now() - start;
-    const trace = {
-        taskId: task.id,
-        model: options.config.model,
-        variant: options.variant,
-        commitSha: getGitCommitSha(),
-        response: text,
-        toolCalls: captured,
-        filesRead: [...filesRead],
-        symbolsQueried: [...symbolsQueried],
-        usage: {
-            inputTokens: usage?.inputTokens ?? 0,
-            outputTokens: usage?.outputTokens ?? 0,
-            totalTokens: (usage?.inputTokens ?? 0) + (usage?.outputTokens ?? 0),
-        },
-        durationMs,
-        startedAt,
-    };
-    options.onTaskComplete?.(task.id, trace);
-    return trace;
+    try {
+        const taskConfig = {
+            ...options.config,
+            workspaceRoot: workspace.workspaceRoot,
+        };
+        const toolset = options.createToolset
+            ? await options.createToolset(taskConfig, task)
+            : { tools: options.tools ?? [] };
+        // Wrap each tool to capture calls
+        const instrumentedTools = toolset.tools.map((tool) => ({
+            ...tool,
+            execute: async (input) => {
+                const start = performance.now();
+                const output = await tool.execute(input);
+                const durationMs = performance.now() - start;
+                captured.push({
+                    name: tool.name,
+                    input,
+                    output: output.length > 2000 ? output.slice(0, 2000) + "…[truncated]" : output,
+                    durationMs,
+                });
+                if (tool.name === "read_file") {
+                    const filePath = input.path ?? input.file_path ?? input.filePath;
+                    if (typeof filePath === "string") {
+                        filesRead.add(filePath);
+                    }
+                }
+                trackStructuralFileReads(tool.name, toolset.projectIndex, input, filesRead);
+                if (STRUCTURAL_TOOLS.has(tool.name)) {
+                    for (const symbolName of getTrackedSymbolNames(tool.name, input)) {
+                        symbolsQueried.add(symbolName);
+                    }
+                }
+                return output;
+            },
+        }));
+        const registry = new ToolRegistry(instrumentedTools);
+        const session = new Session();
+        const agent = new CodingAgent({
+            config: taskConfig,
+            modelClient: options.modelClient,
+            toolRegistry: registry,
+            session,
+        });
+        const startedAt = new Date().toISOString();
+        const start = performance.now();
+        const { text, usage } = await agent.runTurn(task.prompt);
+        const durationMs = performance.now() - start;
+        const trace = {
+            taskId: task.id,
+            model: taskConfig.model,
+            variant: options.variant,
+            commitSha: getGitCommitSha(),
+            sourceWorkspaceRoot: workspace.sourceWorkspaceRoot,
+            workspaceRoot: workspace.workspaceRoot,
+            response: text,
+            toolCalls: captured,
+            filesRead: [...filesRead],
+            symbolsQueried: [...symbolsQueried],
+            usage: {
+                inputTokens: usage?.inputTokens ?? 0,
+                outputTokens: usage?.outputTokens ?? 0,
+                totalTokens: (usage?.inputTokens ?? 0) + (usage?.outputTokens ?? 0),
+            },
+            durationMs,
+            startedAt,
+        };
+        options.onTaskComplete?.(task.id, trace);
+        return trace;
+    }
+    finally {
+        await workspace.cleanup();
+    }
 }
 /**
  * Run all provided benchmark tasks sequentially.

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

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