opencode-dux 1.0.0

package/src/config/loader.test.ts

@@ -0,0 +1,1194 @@
+import { afterEach, beforeEach, describe, expect, spyOn, test } from 'bun:test';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { loadAgentPrompt, loadPluginConfig } from './loader';
+
+// Test deepMerge indirectly through loadPluginConfig behavior
+// since deepMerge is not exported
+
+describe('loadPluginConfig', () => {
+  let tempDir: string;
+  let userConfigDir: string;
+  let originalEnv: typeof process.env;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'loader-test-'));
+    userConfigDir = path.join(tempDir, 'user-config');
+    originalEnv = { ...process.env };
+    // Isolate from real user config
+    delete process.env.OPENCODE_CONFIG_DIR;
+    process.env.XDG_CONFIG_HOME = userConfigDir;
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+    process.env = originalEnv;
+  });
+
+  test('returns empty config when no config files exist', () => {
+    const projectDir = path.join(tempDir, 'project');
+    fs.mkdirSync(projectDir, { recursive: true });
+    const config = loadPluginConfig(projectDir);
+    expect(config).toEqual({});
+  });
+
+  test('loads project config from .opencode directory', () => {
+    const projectDir = path.join(tempDir, 'project');
+    const projectConfigDir = path.join(projectDir, '.opencode');
+    fs.mkdirSync(projectConfigDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(projectConfigDir, 'opencode-dux.json'),
+      JSON.stringify({
+        agents: {
+          oracle: { model: 'test/model' },
+        },
+      }),
+    );
+
+    const config = loadPluginConfig(projectDir);
+    expect(config.agents?.oracle?.model).toBe('test/model');
+  });
+
+  test('loads scoringEngineVersion flag when configured', () => {
+    const projectDir = path.join(tempDir, 'project');
+    const projectConfigDir = path.join(projectDir, '.opencode');
+    fs.mkdirSync(projectConfigDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(projectConfigDir, 'opencode-dux.json'),
+      JSON.stringify({
+        scoringEngineVersion: 'v2-shadow',
+      }),
+    );
+
+    const config = loadPluginConfig(projectDir);
+    expect(config.scoringEngineVersion).toBe('v2-shadow');
+  });
+
+  test('loads balanceProviderUsage flag when configured', () => {
+    const projectDir = path.join(tempDir, 'project');
+    const projectConfigDir = path.join(projectDir, '.opencode');
+    fs.mkdirSync(projectConfigDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(projectConfigDir, 'opencode-dux.json'),
+      JSON.stringify({
+        balanceProviderUsage: true,
+      }),
+    );
+
+    const config = loadPluginConfig(projectDir);
+    expect(config.balanceProviderUsage).toBe(true);
+  });
+
+  test('loads autoUpdate flag when configured', () => {
+    const projectDir = path.join(tempDir, 'project');
+    const projectConfigDir = path.join(projectDir, '.opencode');
+    fs.mkdirSync(projectConfigDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(projectConfigDir, 'opencode-dux.json'),
+      JSON.stringify({
+        autoUpdate: false,
+      }),
+    );
+
+    const config = loadPluginConfig(projectDir);
+    expect(config.autoUpdate).toBe(false);
+  });
+
+  test('loads manual plan structure when configured', () => {
+    const projectDir = path.join(tempDir, 'project');
+    const projectConfigDir = path.join(projectDir, '.opencode');
+    fs.mkdirSync(projectConfigDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(projectConfigDir, 'opencode-dux.json'),
+      JSON.stringify({
+        manualPlan: {
+          orchestrator: {
+            primary: 'openai/gpt-5.5',
+            fallback1: 'anthropic/claude-opus-4-6',
+            fallback2: 'chutes/kimi-k2.5',
+            fallback3: 'opencode/gpt-5-nano',
+          },
+          oracle: {
+            primary: 'openai/gpt-5.5',
+            fallback1: 'anthropic/claude-opus-4-6',
+            fallback2: 'chutes/Qwen/Qwen3-Coder-480B-A35B-Instruct-FP8-TEE',
+            fallback3: 'opencode/gpt-5-nano',
+          },
+          designer: {
+            primary: 'openai/gpt-5.5',
+            fallback1: 'anthropic/claude-opus-4-6',
+            fallback2: 'chutes/kimi-k2.5',
+            fallback3: 'opencode/gpt-5-nano',
+          },
+          explorer: {
+            primary: 'openai/gpt-5.5',
+            fallback1: 'anthropic/claude-opus-4-6',
+            fallback2: 'chutes/kimi-k2.5',
+            fallback3: 'opencode/gpt-5-nano',
+          },
+          librarian: {
+            primary: 'openai/gpt-5.5',
+            fallback1: 'anthropic/claude-opus-4-6',
+            fallback2: 'chutes/kimi-k2.5',
+            fallback3: 'opencode/gpt-5-nano',
+          },
+          fixer: {
+            primary: 'openai/gpt-5.5',
+            fallback1: 'anthropic/claude-opus-4-6',
+            fallback2: 'chutes/kimi-k2.5',
+            fallback3: 'opencode/gpt-5-nano',
+          },
+        },
+      }),
+    );
+
+    const config = loadPluginConfig(projectDir);
+    expect(config.manualPlan?.oracle?.fallback2).toBe(
+      'chutes/Qwen/Qwen3-Coder-480B-A35B-Instruct-FP8-TEE',
+    );
+  });
+
+  test('ignores invalid config (schema violation or malformed JSON)', () => {
+    const projectDir = path.join(tempDir, 'project');
+    const projectConfigDir = path.join(projectDir, '.opencode');
+    fs.mkdirSync(projectConfigDir, { recursive: true });
+
+    // Test 1: Invalid temperature (out of range)
+    fs.writeFileSync(
+      path.join(projectConfigDir, 'opencode-dux.json'),
+      JSON.stringify({ agents: { oracle: { temperature: 5 } } }),
+    );
+    expect(loadPluginConfig(projectDir)).toEqual({});
+
+    // Test 2: Malformed JSON
+    fs.writeFileSync(
+      path.join(projectConfigDir, 'opencode-dux.json'),
+      '{ invalid json }',
+    );
+    expect(loadPluginConfig(projectDir)).toEqual({});
+  });
+
+  test('respects OPENCODE_CONFIG_DIR for user config location', () => {
+    const customDir = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'omc-opencode-config-'),
+    );
+    process.env.OPENCODE_CONFIG_DIR = customDir;
+
+    // Write plugin config in the custom directory
+    fs.writeFileSync(
+      path.join(customDir, 'opencode-dux.json'),
+      JSON.stringify({
+        agents: { oracle: { model: 'custom/model-from-opencode-config-dir' } },
+      }),
+    );
+
+    const projectDir = path.join(tempDir, 'project');
+    fs.mkdirSync(projectDir, { recursive: true });
+
+    const config = loadPluginConfig(projectDir);
+    expect(config.agents?.oracle?.model).toBe(
+      'custom/model-from-opencode-config-dir',
+    );
+
+    fs.rmSync(customDir, { recursive: true, force: true });
+  });
+
+  test('falls back to default user config dir when OPENCODE_CONFIG_DIR has no config', () => {
+    const customDir = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'omc-opencode-config-empty-'),
+    );
+    process.env.OPENCODE_CONFIG_DIR = customDir;
+
+    const defaultConfigDir = path.join(userConfigDir, 'opencode');
+    fs.mkdirSync(defaultConfigDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(defaultConfigDir, 'opencode-dux.json'),
+      JSON.stringify({
+        agents: { oracle: { model: 'fallback/default-config' } },
+      }),
+    );
+
+    const projectDir = path.join(tempDir, 'project');
+    fs.mkdirSync(projectDir, { recursive: true });
+
+    const config = loadPluginConfig(projectDir);
+    expect(config.agents?.oracle?.model).toBe('fallback/default-config');
+
+    fs.rmSync(customDir, { recursive: true, force: true });
+  });
+});
+
+describe('deepMerge behavior', () => {
+  let tempDir: string;
+  let userConfigDir: string;
+  let originalEnv: typeof process.env;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'merge-test-'));
+    userConfigDir = path.join(tempDir, 'user-config');
+    originalEnv = { ...process.env };
+
+    // Set XDG_CONFIG_HOME to control user config location
+    delete process.env.OPENCODE_CONFIG_DIR;
+    process.env.XDG_CONFIG_HOME = userConfigDir;
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+    process.env = originalEnv;
+  });
+
+  test('merges nested agent configs from user and project', () => {
+    // Create user config
+    const userOpencodeDir = path.join(userConfigDir, 'opencode');
+    fs.mkdirSync(userOpencodeDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(userOpencodeDir, 'opencode-dux.json'),
+      JSON.stringify({
+        agents: {
+          oracle: { model: 'user/oracle-model', temperature: 0.5 },
+          explorer: { model: 'user/explorer-model' },
+        },
+      }),
+    );
+
+    // Create project config (should override/merge with user)
+    const projectDir = path.join(tempDir, 'project');
+    const projectConfigDir = path.join(projectDir, '.opencode');
+    fs.mkdirSync(projectConfigDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(projectConfigDir, 'opencode-dux.json'),
+      JSON.stringify({
+        agents: {
+          oracle: { temperature: 0.8 }, // Override temperature only
+          designer: { model: 'project/designer-model' }, // Add new agent
+        },
+      }),
+    );
+
+    const config = loadPluginConfig(projectDir);
+
+    // oracle: model from user, temperature from project
+    expect(config.agents?.oracle?.model).toBe('user/oracle-model');
+    expect(config.agents?.oracle?.temperature).toBe(0.8);
+
+    // explorer: from user only
+    expect(config.agents?.explorer?.model).toBe('user/explorer-model');
+
+    // designer: from project only
+    expect(config.agents?.designer?.model).toBe('project/designer-model');
+  });
+
+  test('handles missing user config gracefully', () => {
+    // Don't create user config, only project
+    const projectDir = path.join(tempDir, 'project');
+    const projectConfigDir = path.join(projectDir, '.opencode');
+    fs.mkdirSync(projectConfigDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(projectConfigDir, 'opencode-dux.json'),
+      JSON.stringify({
+        agents: {
+          oracle: { model: 'project/model' },
+        },
+      }),
+    );
+
+    const config = loadPluginConfig(projectDir);
+    expect(config.agents?.oracle?.model).toBe('project/model');
+  });
+
+  test('handles missing project config gracefully', () => {
+    const userOpencodeDir = path.join(userConfigDir, 'opencode');
+    fs.mkdirSync(userOpencodeDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(userOpencodeDir, 'opencode-dux.json'),
+      JSON.stringify({
+        agents: {
+          oracle: { model: 'user/model' },
+        },
+      }),
+    );
+
+    // No project config
+    const projectDir = path.join(tempDir, 'project');
+    fs.mkdirSync(projectDir, { recursive: true });
+
+    const config = loadPluginConfig(projectDir);
+    expect(config.agents?.oracle?.model).toBe('user/model');
+  });
+
+  test('merges fallback timeout and chains from user and project', () => {
+    const userOpencodeDir = path.join(userConfigDir, 'opencode');
+    fs.mkdirSync(userOpencodeDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(userOpencodeDir, 'opencode-dux.json'),
+      JSON.stringify({
+        fallback: {
+          timeoutMs: 15000,
+          chains: {
+            oracle: ['openai/gpt-5.5', 'opencode/glm-4.7-free'],
+          },
+        },
+      }),
+    );
+
+    const projectDir = path.join(tempDir, 'project');
+    const projectConfigDir = path.join(projectDir, '.opencode');
+    fs.mkdirSync(projectConfigDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(projectConfigDir, 'opencode-dux.json'),
+      JSON.stringify({
+        fallback: {
+          chains: {
+            explorer: ['google/antigravity-gemini-3-flash'],
+          },
+        },
+      }),
+    );
+
+    const config = loadPluginConfig(projectDir);
+    expect(config.fallback?.timeoutMs).toBe(15000);
+    expect(config.fallback?.chains.oracle).toEqual([
+      'openai/gpt-5.5',
+      'opencode/glm-4.7-free',
+    ]);
+    expect(config.fallback?.chains.explorer).toEqual([
+      'google/antigravity-gemini-3-flash',
+    ]);
+  });
+
+  test('preserves fallback chains with additional agent keys', () => {
+    const projectDir = path.join(tempDir, 'project');
+    const projectConfigDir = path.join(projectDir, '.opencode');
+    fs.mkdirSync(projectConfigDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(projectConfigDir, 'opencode-dux.json'),
+      JSON.stringify({
+        fallback: {
+          chains: {
+            writing: ['openai/gpt-5.5'],
+          },
+        },
+      }),
+    );
+
+    const config = loadPluginConfig(projectDir);
+    expect(config.fallback?.chains.writing).toEqual(['openai/gpt-5.5']);
+  });
+});
+
+describe('preset resolution', () => {
+  let tempDir: string;
+  let originalEnv: typeof process.env;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'preset-test-'));
+    originalEnv = { ...process.env };
+    delete process.env.OPENCODE_CONFIG_DIR;
+    process.env.XDG_CONFIG_HOME = path.join(tempDir, 'user-config');
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+    process.env = originalEnv;
+  });
+
+  test('backward compatibility: config with only agents works unchanged', () => {
+    const projectDir = path.join(tempDir, 'project');
+    const projectConfigDir = path.join(projectDir, '.opencode');
+    fs.mkdirSync(projectConfigDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(projectConfigDir, 'opencode-dux.json'),
+      JSON.stringify({
+        agents: { oracle: { model: 'direct-model' } },
+      }),
+    );
+
+    const config = loadPluginConfig(projectDir);
+    expect(config.agents?.oracle?.model).toBe('direct-model');
+    expect(config.preset).toBeUndefined();
+  });
+
+  test("preset applied: preset + presets returns preset's agents", () => {
+    const projectDir = path.join(tempDir, 'project');
+    const projectConfigDir = path.join(projectDir, '.opencode');
+    fs.mkdirSync(projectConfigDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(projectConfigDir, 'opencode-dux.json'),
+      JSON.stringify({
+        preset: 'fast',
+        presets: {
+          fast: { oracle: { model: 'fast-model' } },
+        },
+      }),
+    );
+
+    const config = loadPluginConfig(projectDir);
+    expect(config.agents?.oracle?.model).toBe('fast-model');
+  });
+
+  test('root agents override preset agents', () => {
+    const projectDir = path.join(tempDir, 'project');
+    const projectConfigDir = path.join(projectDir, '.opencode');
+    fs.mkdirSync(projectConfigDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(projectConfigDir, 'opencode-dux.json'),
+      JSON.stringify({
+        preset: 'fast',
+        presets: {
+          fast: {
+            oracle: { model: 'fast-model', temperature: 0.1 },
+            explorer: { model: 'explorer-model' },
+          },
+        },
+        agents: {
+          oracle: { temperature: 0.9 }, // Should override preset temperature
+        },
+      }),
+    );
+
+    const config = loadPluginConfig(projectDir);
+    expect(config.agents?.oracle?.model).toBe('fast-model');
+    expect(config.agents?.oracle?.temperature).toBe(0.9);
+    expect(config.agents?.explorer?.model).toBe('explorer-model');
+  });
+
+  test('missing preset: preset set but not in presets -> returns empty/root agents', () => {
+    const projectDir = path.join(tempDir, 'project');
+    const projectConfigDir = path.join(projectDir, '.opencode');
+    fs.mkdirSync(projectConfigDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(projectConfigDir, 'opencode-dux.json'),
+      JSON.stringify({
+        preset: 'nonexistent',
+        presets: {
+          other: { oracle: { model: 'other' } },
+        },
+        agents: { oracle: { model: 'root' } },
+      }),
+    );
+
+    const config = loadPluginConfig(projectDir);
+    expect(config.agents?.oracle?.model).toBe('root');
+  });
+
+  test('preset only: no root agents, just preset works', () => {
+    const projectDir = path.join(tempDir, 'project');
+    const projectConfigDir = path.join(projectDir, '.opencode');
+    fs.mkdirSync(projectConfigDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(projectConfigDir, 'opencode-dux.json'),
+      JSON.stringify({
+        preset: 'dev',
+        presets: {
+          dev: { oracle: { model: 'dev-model' } },
+        },
+      }),
+    );
+
+    const config = loadPluginConfig(projectDir);
+    expect(config.agents?.oracle?.model).toBe('dev-model');
+  });
+
+  test('invalid preset shape: bad agent config in preset fails schema validation', () => {
+    const projectDir = path.join(tempDir, 'project');
+    const projectConfigDir = path.join(projectDir, '.opencode');
+    fs.mkdirSync(projectConfigDir, { recursive: true });
+
+    // preset agents with invalid temperature
+    fs.writeFileSync(
+      path.join(projectConfigDir, 'opencode-dux.json'),
+      JSON.stringify({
+        preset: 'invalid',
+        presets: {
+          invalid: { oracle: { temperature: 5 } },
+        },
+      }),
+    );
+
+    // Should return empty config due to validation failure
+    expect(loadPluginConfig(projectDir)).toEqual({});
+  });
+
+  test('nonexistent preset from config warns and falls back to root agents', () => {
+    const projectDir = path.join(tempDir, 'project');
+    const projectConfigDir = path.join(projectDir, '.opencode');
+    fs.mkdirSync(projectConfigDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(projectConfigDir, 'opencode-dux.json'),
+      JSON.stringify({
+        preset: 'nonexistent',
+        presets: {
+          other: { oracle: { model: 'other' } },
+        },
+        agents: { oracle: { model: 'root' } },
+      }),
+    );
+
+    const consoleWarnSpy = spyOn(console, 'warn');
+    const config = loadPluginConfig(projectDir);
+    expect(config.agents?.oracle?.model).toBe('root');
+    expect(consoleWarnSpy).toHaveBeenCalled();
+    const warningMessage = consoleWarnSpy.mock.calls[0][0] as string;
+    expect(warningMessage).toContain('Preset "nonexistent" not found');
+    expect(warningMessage).toContain('Available presets: other');
+  });
+
+  test('nonexistent preset with no root agents returns empty agents', () => {
+    const projectDir = path.join(tempDir, 'project');
+    const projectConfigDir = path.join(projectDir, '.opencode');
+    fs.mkdirSync(projectConfigDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(projectConfigDir, 'opencode-dux.json'),
+      JSON.stringify({
+        preset: 'nonexistent',
+        presets: {
+          other: { oracle: { model: 'other' } },
+        },
+      }),
+    );
+
+    const consoleWarnSpy = spyOn(console, 'warn');
+    const config = loadPluginConfig(projectDir);
+    expect(config.agents).toBeUndefined();
+    expect(consoleWarnSpy).toHaveBeenCalled();
+    const warningMessage = consoleWarnSpy.mock.calls[0][0] as string;
+    expect(warningMessage).toContain('Preset "nonexistent" not found');
+  });
+
+  test('options from preset are deep-merged with root agents', () => {
+    const projectDir = path.join(tempDir, 'project');
+    const projectConfigDir = path.join(projectDir, '.opencode');
+    fs.mkdirSync(projectConfigDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(projectConfigDir, 'opencode-dux.json'),
+      JSON.stringify({
+        preset: 'openai',
+        presets: {
+          openai: {
+            oracle: {
+              model: 'openai/gpt-5.5',
+              options: { textVerbosity: 'low' },
+            },
+          },
+        },
+        agents: {
+          oracle: {
+            options: { reasoningEffort: 'medium' },
+          },
+        },
+      }),
+    );
+
+    const config = loadPluginConfig(projectDir);
+    expect(config.agents?.oracle?.model).toBe('openai/gpt-5.5');
+    // deepMerge should combine both option keys
+    expect(config.agents?.oracle?.options).toEqual({
+      textVerbosity: 'low',
+      reasoningEffort: 'medium',
+    });
+  });
+
+  test('options from preset only work without root agents', () => {
+    const projectDir = path.join(tempDir, 'project');
+    const projectConfigDir = path.join(projectDir, '.opencode');
+    fs.mkdirSync(projectConfigDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(projectConfigDir, 'opencode-dux.json'),
+      JSON.stringify({
+        preset: 'anthropic-thinking',
+        presets: {
+          'anthropic-thinking': {
+            oracle: {
+              model: 'anthropic/claude-sonnet-4-6',
+              options: {
+                thinking: { type: 'enabled', budgetTokens: 16000 },
+              },
+            },
+          },
+        },
+      }),
+    );
+
+    const config = loadPluginConfig(projectDir);
+    expect(config.agents?.oracle?.model).toBe('anthropic/claude-sonnet-4-6');
+    expect(config.agents?.oracle?.options).toEqual({
+      thinking: { type: 'enabled', budgetTokens: 16000 },
+    });
+  });
+
+  test('root options override preset options for same key', () => {
+    const projectDir = path.join(tempDir, 'project');
+    const projectConfigDir = path.join(projectDir, '.opencode');
+    fs.mkdirSync(projectConfigDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(projectConfigDir, 'opencode-dux.json'),
+      JSON.stringify({
+        preset: 'concise',
+        presets: {
+          concise: {
+            oracle: {
+              model: 'openai/gpt-5.5',
+              options: { textVerbosity: 'low' },
+            },
+          },
+        },
+        agents: {
+          oracle: {
+            options: { textVerbosity: 'high' },
+          },
+        },
+      }),
+    );
+
+    const config = loadPluginConfig(projectDir);
+    expect(config.agents?.oracle?.model).toBe('openai/gpt-5.5');
+    // root wins over preset for same key
+    expect(config.agents?.oracle?.options).toEqual({
+      textVerbosity: 'high',
+    });
+  });
+});
+
+describe('environment variable preset override', () => {
+  let tempDir: string;
+  let originalEnv: typeof process.env;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'env-preset-test-'));
+    originalEnv = { ...process.env };
+    delete process.env.OPENCODE_CONFIG_DIR;
+    process.env.XDG_CONFIG_HOME = path.join(tempDir, 'user-config');
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+    process.env = originalEnv;
+  });
+
+  test('Env var overrides preset from config file', () => {
+    const projectDir = path.join(tempDir, 'project');
+    const projectConfigDir = path.join(projectDir, '.opencode');
+    fs.mkdirSync(projectConfigDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(projectConfigDir, 'opencode-dux.json'),
+      JSON.stringify({
+        preset: 'config-preset',
+        presets: {
+          'config-preset': { oracle: { model: 'config-model' } },
+          'env-preset': { oracle: { model: 'env-model' } },
+        },
+      }),
+    );
+
+    process.env.OH_MY_OPENCODE_SLIM_PRESET = 'env-preset';
+    const config = loadPluginConfig(projectDir);
+    expect(config.preset).toBe('env-preset');
+    expect(config.agents?.oracle?.model).toBe('env-model');
+  });
+
+  test('Env var works when config has no preset', () => {
+    const projectDir = path.join(tempDir, 'project');
+    const projectConfigDir = path.join(projectDir, '.opencode');
+    fs.mkdirSync(projectConfigDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(projectConfigDir, 'opencode-dux.json'),
+      JSON.stringify({
+        presets: {
+          'env-preset': { oracle: { model: 'env-model' } },
+        },
+      }),
+    );
+
+    process.env.OH_MY_OPENCODE_SLIM_PRESET = 'env-preset';
+    const config = loadPluginConfig(projectDir);
+    expect(config.preset).toBe('env-preset');
+    expect(config.agents?.oracle?.model).toBe('env-model');
+  });
+
+  test('Env var is ignored if empty string', () => {
+    const projectDir = path.join(tempDir, 'project');
+    const projectConfigDir = path.join(projectDir, '.opencode');
+    fs.mkdirSync(projectConfigDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(projectConfigDir, 'opencode-dux.json'),
+      JSON.stringify({
+        preset: 'config-preset',
+        presets: {
+          'config-preset': { oracle: { model: 'config-model' } },
+        },
+      }),
+    );
+
+    process.env.OH_MY_OPENCODE_SLIM_PRESET = '';
+    const config = loadPluginConfig(projectDir);
+    expect(config.preset).toBe('config-preset');
+    expect(config.agents?.oracle?.model).toBe('config-model');
+  });
+
+  test('Env var is ignored if undefined', () => {
+    const projectDir = path.join(tempDir, 'project');
+    const projectConfigDir = path.join(projectDir, '.opencode');
+    fs.mkdirSync(projectConfigDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(projectConfigDir, 'opencode-dux.json'),
+      JSON.stringify({
+        preset: 'config-preset',
+        presets: {
+          'config-preset': { oracle: { model: 'config-model' } },
+        },
+      }),
+    );
+
+    delete process.env.OH_MY_OPENCODE_SLIM_PRESET;
+    const config = loadPluginConfig(projectDir);
+    expect(config.preset).toBe('config-preset');
+    expect(config.agents?.oracle?.model).toBe('config-model');
+  });
+
+  test('Env var with nonexistent preset warns and falls back', () => {
+    const projectDir = path.join(tempDir, 'project');
+    const projectConfigDir = path.join(projectDir, '.opencode');
+    fs.mkdirSync(projectConfigDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(projectConfigDir, 'opencode-dux.json'),
+      JSON.stringify({
+        preset: 'config-preset',
+        presets: {
+          'config-preset': { oracle: { model: 'config-model' } },
+        },
+        agents: { oracle: { model: 'fallback' } },
+      }),
+    );
+
+    process.env.OH_MY_OPENCODE_SLIM_PRESET = 'typo-preset';
+    const consoleWarnSpy = spyOn(console, 'warn');
+    const config = loadPluginConfig(projectDir);
+    expect(config.preset).toBe('typo-preset');
+    expect(config.agents?.oracle?.model).toBe('fallback');
+    expect(consoleWarnSpy).toHaveBeenCalled();
+    const calls = consoleWarnSpy.mock.calls as string[][];
+    const warningMessage =
+      calls.find((call) => call[0]?.includes('typo-preset'))?.[0] || '';
+    expect(warningMessage).toContain('Preset "typo-preset" not found');
+    expect(warningMessage).toContain('environment variable');
+    expect(warningMessage).toContain('config-preset');
+  });
+});
+
+describe('JSONC config support', () => {
+  let tempDir: string;
+  let originalEnv: typeof process.env;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'jsonc-test-'));
+    originalEnv = { ...process.env };
+    delete process.env.OPENCODE_CONFIG_DIR;
+    process.env.XDG_CONFIG_HOME = path.join(tempDir, 'user-config');
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+    process.env = originalEnv;
+  });
+
+  test('loads .jsonc file with single-line comments', () => {
+    const projectDir = path.join(tempDir, 'project');
+    const projectConfigDir = path.join(projectDir, '.opencode');
+    fs.mkdirSync(projectConfigDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(projectConfigDir, 'opencode-dux.jsonc'),
+      `{
+        // This is a comment
+        "agents": {
+          "oracle": { "model": "test/model" } // inline comment
+        }
+      }`,
+    );
+
+    const config = loadPluginConfig(projectDir);
+    expect(config.agents?.oracle?.model).toBe('test/model');
+  });
+
+  test('loads .jsonc file with multi-line comments', () => {
+    const projectDir = path.join(tempDir, 'project');
+    const projectConfigDir = path.join(projectDir, '.opencode');
+    fs.mkdirSync(projectConfigDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(projectConfigDir, 'opencode-dux.jsonc'),
+      `{
+        /* Multi-line
+           comment block */
+        "agents": {
+          "explorer": { "model": "explorer-model" }
+        }
+      }`,
+    );
+
+    const config = loadPluginConfig(projectDir);
+    expect(config.agents?.explorer?.model).toBe('explorer-model');
+  });
+
+  test('loads .jsonc file with trailing commas', () => {
+    const projectDir = path.join(tempDir, 'project');
+    const projectConfigDir = path.join(projectDir, '.opencode');
+    fs.mkdirSync(projectConfigDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(projectConfigDir, 'opencode-dux.jsonc'),
+      `{
+        "agents": {
+          "oracle": { "model": "test-model", },
+        },
+      }`,
+    );
+
+    const config = loadPluginConfig(projectDir);
+    expect(config.agents?.oracle?.model).toBe('test-model');
+  });
+
+  test('prefers .jsonc over .json when both exist', () => {
+    const projectDir = path.join(tempDir, 'project');
+    const projectConfigDir = path.join(projectDir, '.opencode');
+    fs.mkdirSync(projectConfigDir, { recursive: true });
+
+    // Create both files
+    fs.writeFileSync(
+      path.join(projectConfigDir, 'opencode-dux.json'),
+      JSON.stringify({ agents: { oracle: { model: 'json-model' } } }),
+    );
+    fs.writeFileSync(
+      path.join(projectConfigDir, 'opencode-dux.jsonc'),
+      `{
+        // JSONC version
+        "agents": { "oracle": { "model": "jsonc-model" } }
+      }`,
+    );
+
+    const config = loadPluginConfig(projectDir);
+    expect(config.agents?.oracle?.model).toBe('jsonc-model');
+  });
+
+  test('falls back to .json when .jsonc does not exist', () => {
+    const projectDir = path.join(tempDir, 'project');
+    const projectConfigDir = path.join(projectDir, '.opencode');
+    fs.mkdirSync(projectConfigDir, { recursive: true });
+
+    // Only create .json file
+    fs.writeFileSync(
+      path.join(projectConfigDir, 'opencode-dux.json'),
+      JSON.stringify({ agents: { oracle: { model: 'json-model' } } }),
+    );
+
+    const config = loadPluginConfig(projectDir);
+    expect(config.agents?.oracle?.model).toBe('json-model');
+  });
+
+  test('loads user config from .jsonc', () => {
+    const userOpencodeDir = path.join(tempDir, 'user-config', 'opencode');
+    fs.mkdirSync(userOpencodeDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(userOpencodeDir, 'opencode-dux.jsonc'),
+      `{
+        // User config with comments
+        "agents": { "librarian": { "model": "user-librarian" } }
+      }`,
+    );
+
+    const projectDir = path.join(tempDir, 'project');
+    fs.mkdirSync(projectDir, { recursive: true });
+
+    const config = loadPluginConfig(projectDir);
+    expect(config.agents?.librarian?.model).toBe('user-librarian');
+  });
+
+  test('merges user .jsonc with project .jsonc', () => {
+    const userOpencodeDir = path.join(tempDir, 'user-config', 'opencode');
+    fs.mkdirSync(userOpencodeDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(userOpencodeDir, 'opencode-dux.jsonc'),
+      `{
+        // User config
+        "agents": {
+          "oracle": { "model": "user-oracle", "temperature": 0.5 }
+        }
+      }`,
+    );
+
+    const projectDir = path.join(tempDir, 'project');
+    const projectConfigDir = path.join(projectDir, '.opencode');
+    fs.mkdirSync(projectConfigDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(projectConfigDir, 'opencode-dux.jsonc'),
+      `{
+        // Project config
+        "agents": { "oracle": { "temperature": 0.8 } }
+      }`,
+    );
+
+    const config = loadPluginConfig(projectDir);
+    expect(config.agents?.oracle?.model).toBe('user-oracle');
+    expect(config.agents?.oracle?.temperature).toBe(0.8);
+  });
+
+  test('handles complex JSONC with mixed comments and trailing commas', () => {
+    const projectDir = path.join(tempDir, 'project');
+    const projectConfigDir = path.join(projectDir, '.opencode');
+    fs.mkdirSync(projectConfigDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(projectConfigDir, 'opencode-dux.jsonc'),
+      `{
+        // Main configuration
+        "preset": "dev",
+        /* Presets definition */
+        "presets": {
+          "dev": {
+            // Development agents
+            "oracle": { "model": "dev-oracle", },
+            "explorer": { "model": "dev-explorer", },
+          },
+        },
+      }`,
+    );
+
+    const config = loadPluginConfig(projectDir);
+    expect(config.preset).toBe('dev');
+    expect(config.agents?.oracle?.model).toBe('dev-oracle');
+    expect(config.agents?.explorer?.model).toBe('dev-explorer');
+  });
+});
+
+describe('loadAgentPrompt', () => {
+  let tempDir: string;
+  let originalEnv: typeof process.env;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'prompt-test-'));
+    originalEnv = { ...process.env };
+    delete process.env.OPENCODE_CONFIG_DIR;
+    process.env.XDG_CONFIG_HOME = tempDir;
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+    process.env = originalEnv;
+  });
+
+  test('returns empty object when no prompt files exist', () => {
+    const result = loadAgentPrompt('oracle');
+    expect(result).toEqual({});
+  });
+
+  test('loads replacement prompt from {agent}.md', () => {
+    const promptsDir = path.join(tempDir, 'opencode', 'opencode-dux');
+    fs.mkdirSync(promptsDir, { recursive: true });
+    fs.writeFileSync(path.join(promptsDir, 'oracle.md'), 'replacement prompt');
+
+    const result = loadAgentPrompt('oracle');
+    expect(result.prompt).toBe('replacement prompt');
+    expect(result.appendPrompt).toBeUndefined();
+  });
+
+  test('loads append prompt from {agent}_append.md', () => {
+    const promptsDir = path.join(tempDir, 'opencode', 'opencode-dux');
+    fs.mkdirSync(promptsDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(promptsDir, 'oracle_append.md'),
+      'append prompt',
+    );
+
+    const result = loadAgentPrompt('oracle');
+    expect(result.prompt).toBeUndefined();
+    expect(result.appendPrompt).toBe('append prompt');
+  });
+
+  test('loads both replacement and append prompts', () => {
+    const promptsDir = path.join(tempDir, 'opencode', 'opencode-dux');
+    fs.mkdirSync(promptsDir, { recursive: true });
+    fs.writeFileSync(path.join(promptsDir, 'oracle.md'), 'replacement prompt');
+    fs.writeFileSync(
+      path.join(promptsDir, 'oracle_append.md'),
+      'append prompt',
+    );
+
+    const result = loadAgentPrompt('oracle');
+    expect(result.prompt).toBe('replacement prompt');
+    expect(result.appendPrompt).toBe('append prompt');
+  });
+
+  test('handles file read errors gracefully', () => {
+    const promptsDir = path.join(tempDir, 'opencode', 'opencode-dux');
+    fs.mkdirSync(promptsDir, { recursive: true });
+    const promptPath = path.join(promptsDir, 'error-agent.md');
+    fs.writeFileSync(promptPath, 'content');
+
+    const consoleWarnSpy = spyOn(console, 'warn');
+
+    // Use a unique agent name and check for it specifically
+    const originalReadFileSync = fs.readFileSync;
+    const readSpy = spyOn(fs, 'readFileSync').mockImplementation(((
+      ...args: Parameters<typeof fs.readFileSync>
+    ) => {
+      const [p] = args;
+      if (typeof p === 'string' && p.includes('error-agent.md')) {
+        throw new Error('Read error');
+      }
+      return originalReadFileSync(...args);
+    }) as typeof fs.readFileSync);
+
+    try {
+      const result = loadAgentPrompt('error-agent');
+      expect(result.prompt).toBeUndefined();
+
+      const warningFound = consoleWarnSpy.mock.calls.some((call) =>
+        (call[0] as string).includes('Error reading prompt file'),
+      );
+      expect(warningFound).toBe(true);
+    } finally {
+      readSpy.mockRestore();
+    }
+  });
+
+  test('prefers preset prompt files over root prompts', () => {
+    const promptsDir = path.join(tempDir, 'opencode', 'opencode-dux');
+    const presetDir = path.join(promptsDir, 'test');
+    fs.mkdirSync(presetDir, { recursive: true });
+
+    fs.writeFileSync(path.join(promptsDir, 'oracle.md'), 'root replacement');
+    fs.writeFileSync(path.join(presetDir, 'oracle.md'), 'preset replacement');
+    fs.writeFileSync(
+      path.join(promptsDir, 'oracle_append.md'),
+      'root append prompt',
+    );
+    fs.writeFileSync(
+      path.join(presetDir, 'oracle_append.md'),
+      'preset append prompt',
+    );
+
+    const result = loadAgentPrompt('oracle', 'test');
+    expect(result.prompt).toBe('preset replacement');
+    expect(result.appendPrompt).toBe('preset append prompt');
+  });
+
+  test('falls back to root prompt files when preset files are missing', () => {
+    const promptsDir = path.join(tempDir, 'opencode', 'opencode-dux');
+    const presetDir = path.join(promptsDir, 'test');
+    fs.mkdirSync(presetDir, { recursive: true });
+
+    fs.writeFileSync(path.join(promptsDir, 'oracle.md'), 'root replacement');
+    fs.writeFileSync(
+      path.join(promptsDir, 'oracle_append.md'),
+      'root append prompt',
+    );
+
+    const result = loadAgentPrompt('oracle', 'test');
+    expect(result.prompt).toBe('root replacement');
+    expect(result.appendPrompt).toBe('root append prompt');
+  });
+
+  test('falls back independently between preset and root files', () => {
+    const promptsDir = path.join(tempDir, 'opencode', 'opencode-dux');
+    const presetDir = path.join(promptsDir, 'test');
+    fs.mkdirSync(presetDir, { recursive: true });
+
+    fs.writeFileSync(path.join(presetDir, 'oracle.md'), 'preset replacement');
+    fs.writeFileSync(
+      path.join(promptsDir, 'oracle_append.md'),
+      'root append prompt',
+    );
+
+    const result = loadAgentPrompt('oracle', 'test');
+    expect(result.prompt).toBe('preset replacement');
+    expect(result.appendPrompt).toBe('root append prompt');
+  });
+
+  test('ignores unsafe preset names for prompt lookup', () => {
+    const promptsDir = path.join(tempDir, 'opencode', 'opencode-dux');
+    fs.mkdirSync(promptsDir, { recursive: true });
+    fs.writeFileSync(path.join(promptsDir, 'oracle.md'), 'root replacement');
+
+    const result = loadAgentPrompt('oracle', '../test');
+    expect(result.prompt).toBe('root replacement');
+    expect(result.appendPrompt).toBeUndefined();
+  });
+
+  test('falls back to root when preset prompt file read fails', () => {
+    const promptsDir = path.join(tempDir, 'opencode', 'opencode-dux');
+    const presetDir = path.join(promptsDir, 'test');
+    fs.mkdirSync(presetDir, { recursive: true });
+    const presetPromptPath = path.join(presetDir, 'oracle.md');
+    fs.writeFileSync(presetPromptPath, 'preset replacement');
+    fs.writeFileSync(path.join(promptsDir, 'oracle.md'), 'root replacement');
+
+    const consoleWarnSpy = spyOn(console, 'warn');
+    const originalReadFileSync = fs.readFileSync;
+    const readSpy = spyOn(fs, 'readFileSync').mockImplementation(((
+      ...args: Parameters<typeof fs.readFileSync>
+    ) => {
+      const [p] = args;
+      if (typeof p === 'string' && p === presetPromptPath) {
+        throw new Error('Preset read error');
+      }
+      return originalReadFileSync(...args);
+    }) as typeof fs.readFileSync);
+
+    try {
+      const result = loadAgentPrompt('oracle', 'test');
+      expect(result.prompt).toBe('root replacement');
+      expect(consoleWarnSpy).toHaveBeenCalled();
+    } finally {
+      readSpy.mockRestore();
+    }
+  });
+
+  test('works with XDG_CONFIG_HOME environment variable', () => {
+    const customConfigHome = path.join(tempDir, 'custom-xdg');
+    process.env.XDG_CONFIG_HOME = customConfigHome;
+
+    const promptsDir = path.join(
+      customConfigHome,
+      'opencode',
+      'opencode-dux',
+    );
+    fs.mkdirSync(promptsDir, { recursive: true });
+    fs.writeFileSync(path.join(promptsDir, 'xdg-agent.md'), 'xdg prompt');
+
+    const result = loadAgentPrompt('xdg-agent');
+    expect(result.prompt).toBe('xdg prompt');
+  });
+
+  test('respects OPENCODE_CONFIG_DIR for prompt location', () => {
+    const customDir = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'omc-prompt-config-'),
+    );
+    process.env.OPENCODE_CONFIG_DIR = customDir;
+
+    const promptsDir = path.join(customDir, 'opencode-dux');
+    fs.mkdirSync(promptsDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(promptsDir, 'oracle.md'),
+      'prompt from OPENCODE_CONFIG_DIR dir',
+    );
+
+    const result = loadAgentPrompt('oracle');
+    expect(result.prompt).toBe('prompt from OPENCODE_CONFIG_DIR dir');
+
+    fs.rmSync(customDir, { recursive: true, force: true });
+  });
+
+  test('falls back to default prompt dir when OPENCODE_CONFIG_DIR has no prompt', () => {
+    const customDir = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'omc-prompt-config-empty-'),
+    );
+    process.env.OPENCODE_CONFIG_DIR = customDir;
+
+    const promptsDir = path.join(tempDir, 'opencode', 'opencode-dux');
+    fs.mkdirSync(promptsDir, { recursive: true });
+    fs.writeFileSync(path.join(promptsDir, 'oracle.md'), 'fallback prompt');
+
+    const result = loadAgentPrompt('oracle');
+    expect(result.prompt).toBe('fallback prompt');
+
+    fs.rmSync(customDir, { recursive: true, force: true });
+  });
+});