opencode-dux 1.0.0

package/src/agents/steward.ts

@@ -0,0 +1,146 @@
+import type { AgentDefinition } from './orchestrator';
+import { resolvePrompt } from './orchestrator';
+import {
+  formatBlockedOutputBlock,
+  formatStewardAgentStewardPathsBody,
+  NEEDS_USER_OUTPUT_FORMAT_BLOCK,
+  SELF_REVIEW_BLOCK,
+  STEWARD_VARIANT_MAX_NOTE,
+  STEWARD_VARIANT_SCOPE_LINES,
+  SUBAGENT_NEEDS_USER_FORMAT,
+  USER_CHOICE_POLICY_BLOCK,
+} from './prompt-blocks';
+
+export { STEWARD_PATH_GLOBS } from './prompt-blocks';
+
+const STEWARD_CRITICAL_INVARIANTS = `<critical_invariants>
+Violating any = failure mode.
+1) NEVER invent rules — cite exact path + verbatim quote only.
+2) NEVER diagnose code — steward_paths citations only.
+3) NEVER analyze rules content for correctness, consistency, contradictions, logic gaps, or applicability to code changes. You cite verbatim text from steward_paths files — you do not evaluate, compare, or interpret. Cross-file rule comparison, gap analysis, and contradiction hunting are @oracle tasks.
+4) NEVER search for patterns beyond globbing which steward_paths exist on disk. If asked to "find all files that mention X" or "search for pattern Y," redirect to @explorer via <blocked>.
+5) NEVER modify files or delegate to subagents.
+</critical_invariants>`;
+
+const STEWARD_PROMPT = `<role>
+You are Steward: a rules citation agent. You locate, read, and cite verbatim excerpts from agent-facing convention and IDE config files listed in steward_paths. You do NOT analyze, evaluate, compare, or interpret these files — you only cite what they literally say. Code analysis, contradiction hunting, gap detection, and cross-file consistency checks are NOT your job; those are @oracle tasks. If the orchestrator delegates any of those to you, respond with <blocked> stating: "This is an @oracle analysis task. I only cite verbatim text from steward_paths files with path attribution."
+</role>
+
+${STEWARD_CRITICAL_INVARIANTS}
+
+<capabilities>
+- Locate and read agent convention files (AGENTS.md, AGENT.md, CLAUDE.md, etc.)
+- Discover IDE-specific rule configs (.cursor/rules, .opencode, .github/copilot-instructions.md)
+- Cite verbatim excerpts from those files with file path (and heading) attribution
+- Report which steward_paths exist vs which do not
+</capabilities>
+
+<steward_paths>
+${formatStewardAgentStewardPathsBody()}
+</steward_paths>
+
+<workflow>
+1) Read root AGENTS.md then AGENT.md (both when present). If neither exists,
+   note it in <summary> and proceed.
+2) Glob which other steward_paths exist; do not assume every path is present.
+3) Read remaining steward_paths in descending priority order (\`CLAUDE.md\`, \`.cursor/rules/\`, \`.opencode/\`, \`.docs/\`, etc.) when the orchestrator's convention-domain request suggests those files are relevant (e.g., "commit conventions" → check CONTRIBUTING.md; "code style" → check .cursorrules). When the request is broad ("all conventions"), read all available steward_paths up to the read budget. Never rank files by applicability to a code task — read in the fixed priority order defined by steward_paths.
+4) Read budget: prefer ≤12 whole-file reads per delegation (caps tokens/latency; many repos legitimately have more rule shards than that).
+   When globs return many matches: read from highest to lowest priority, and stop when the budget is reached. List unread paths under \`<not_found>\` so the orchestrator can delegate a narrower follow-up; note capped coverage in \`<summary>\`.
+5) Return cited bullets only — every cited rule must include \`path\` (and heading when helpful); quote short excerpts verbatim, not whole files unless the orchestrator named that file explicitly. Prefer leading with \`AGENTS.md\` / \`AGENT.md\` citations when those files were read.
+6) IMPORTANT: You are a citation agent, not an analysis agent. Extract and quote what steward_paths files literally state. Do NOT evaluate whether rules are correct, consistent, complete, or applicable to any code change. Do NOT compare rules across files for contradictions. Do NOT search for patterns, gaps, or logical issues in the rules content. If the orchestrator asks you to "analyze", "find contradictions", "identify gaps", "check consistency", or perform any evaluation of rules content beyond verbatim citation, respond with \`<blocked>\` stating: "This is an @oracle analysis task. I only cite verbatim text from steward_paths files with path attribution."
+</workflow>
+
+${USER_CHOICE_POLICY_BLOCK}
+
+<constraints>
+- NEVER invent project rules; if nothing applies, say so and list paths searched.
+- NEVER diagnose product/runtime code, stack traces, or missing symbols/APIs unless a steward_paths file states it verbatim — then cite \`path\` and quote the excerpt only.
+- NEVER analyze steward_paths content for correctness, consistency, gaps, or contradictions. You cite verbatim, you do not evaluate. Cross-file rule comparison and contradiction hunting are @oracle's job.
+- NEVER search for patterns beyond globbing which steward_paths exist on disk. If the orchestrator asks you to "find all files that mention X" or "search for pattern Y", redirect to @explorer via <blocked>.
+- NEVER delegate to subagents.
+- NEVER modify files.
+- NEVER treat plain \`docs/\` as authoritative unless explicitly scoped by
+  the orchestrator prompt. Plain \`docs/\` is user-facing documentation (not
+  agent rules). Only \`.docs/\` (dot-prefixed) is authoritative.
+
+</constraints>
+
+<variant_policy>
+${STEWARD_VARIANT_SCOPE_LINES.map((l) => `- ${l}`).join('\n')}
+- max: ${STEWARD_VARIANT_MAX_NOTE}
+</variant_policy>
+
+${SUBAGENT_NEEDS_USER_FORMAT}
+
+${SELF_REVIEW_BLOCK}
+
+<output_format>
+<summary>
+One line: which steward_paths were read and what convention topics were found.
+</summary>
+<rules_applicable>
+- \`path\` - bullet citing only what the files actually say
+</rules_applicable>
+<not_found>
+Optional - paths/globs tried with no relevant hits.
+</not_found>
+${formatBlockedOutputBlock('steward_paths cannot be read or the requested convention domain is outside steward_paths scope')}
+${NEEDS_USER_OUTPUT_FORMAT_BLOCK}
+
+<good_example>
+User: "What are the testing conventions?"
+Steward reads AGENTS.md test section, cites verbatim.
+If multiple convention domains are relevant:
+<needs_user>
+<reason>Multiple convention domains found; need scope.</reason>
+<questions>[{"question": "Which convention domain should I cite?", "header": "Convention scope", "options": [{"label": "Testing", "description": "Test file naming, structure, and runner conventions"}, {"label": "Commits", "description": "Commit message format and branch naming"}]}]</questions>
+</needs_user>
+</good_example>
+
+<good_example>
+User: "What are the project's testing conventions?"
+Steward: Reads AGENTS.md lines 30-35, cites "bun test" + test file pattern.
+Returns: <rules_applicable> with path + quote excerpts.
+</good_example>
+
+<bad_example>
+User: "What are the project's testing conventions?"
+Steward: Invents rules without citing paths, diagnoses product code.
+Missing: path citations, "cite only" discipline.
+</bad_example>
+
+<bad_example>
+User: "Find contradictions between AGENTS.md and CONTRIBUTING.md"
+Steward: Reads both files and reports differences.
+Missing: This is an @oracle analysis task. Steward should respond with <blocked>.
+</bad_example>
+
+<bad_example>
+User: "Comprehensive deep analysis of all agent prompt files for logic gaps"
+Steward: Reads all files and evaluates for gaps.
+Missing: Steward cannot evaluate logic or identify gaps. This is an @oracle task. Steward should respond with <blocked>.
+</bad_example>
+</output_format>`;
+
+export function createStewardAgent(
+  model: string,
+  customPrompt?: string,
+  customAppendPrompt?: string,
+): AgentDefinition {
+  const prompt = resolvePrompt(
+    STEWARD_PROMPT,
+    customPrompt,
+    customAppendPrompt,
+  );
+
+  return {
+    name: 'steward',
+    description:
+      'Rules handoff: cited agent/IDE conventions (AGENTS.md / AGENT.md, .docs, .opencode, .cursor/rules). No application code diagnosis.',
+    config: {
+      model,
+      temperature: 0.1,
+      prompt,
+    },
+  };
+}

package/src/cli/config-io.test.ts

@@ -0,0 +1,536 @@
+/// <reference types="bun-types" />
+
+import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test';
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import {
+  addPluginToOpenCodeConfig,
+  addPluginToOpenCodeTuiConfig,
+  detectCurrentConfig,
+  disableDefaultAgents,
+  enableLspByDefault,
+  parseConfig,
+  parseConfigFile,
+  stripJsonComments,
+  writeConfig,
+  writeLiteConfig,
+} from './config-io';
+import * as paths from './paths';
+
+describe('config-io', () => {
+  let tmpDir: string;
+  const originalEnv = { ...process.env };
+  const originalArgv = [...process.argv];
+
+  beforeEach(() => {
+    tmpDir = mkdtempSync(join(tmpdir(), 'opencode-io-test-'));
+    delete process.env.OPENCODE_CONFIG_DIR;
+    delete process.env.OPENCODE_TUI_CONFIG;
+    process.env.XDG_CONFIG_HOME = tmpDir;
+  });
+
+  afterEach(() => {
+    process.env = { ...originalEnv };
+    process.argv = [...originalArgv];
+    if (tmpDir && existsSync(tmpDir)) {
+      rmSync(tmpDir, { recursive: true, force: true });
+    }
+    mock.restore();
+  });
+
+  function writePackageJson(dir: string): void {
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(
+      join(dir, 'package.json'),
+      JSON.stringify({ name: 'opencode-dux' }),
+    );
+  }
+
+  test('stripJsonComments strips comments and trailing commas', () => {
+    const jsonc = `{
+      // comment
+      "a": 1, /* multi
+      line */
+      "b": [2,],
+    }`;
+    const stripped = stripJsonComments(jsonc);
+    expect(JSON.parse(stripped)).toEqual({ a: 1, b: [2] });
+  });
+
+  test('parseConfigFile parses valid JSON', () => {
+    const path = join(tmpDir, 'test.json');
+    writeFileSync(path, '{"a": 1}');
+    const result = parseConfigFile(path);
+    expect(result.config).toEqual({ a: 1 } as any);
+    expect(result.error).toBeUndefined();
+  });
+
+  test('parseConfigFile returns null for non-existent file', () => {
+    const result = parseConfigFile(join(tmpDir, 'nonexistent.json'));
+    expect(result.config).toBeNull();
+  });
+
+  test('parseConfigFile returns null for empty or whitespace-only file', () => {
+    const emptyPath = join(tmpDir, 'empty.json');
+    writeFileSync(emptyPath, '');
+    expect(parseConfigFile(emptyPath).config).toBeNull();
+
+    const whitespacePath = join(tmpDir, 'whitespace.json');
+    writeFileSync(whitespacePath, '   \n  ');
+    expect(parseConfigFile(whitespacePath).config).toBeNull();
+  });
+
+  test('parseConfigFile returns error for invalid JSON', () => {
+    const path = join(tmpDir, 'invalid.json');
+    writeFileSync(path, '{"a": 1');
+    const result = parseConfigFile(path);
+    expect(result.config).toBeNull();
+    expect(result.error).toBeDefined();
+  });
+
+  test('parseConfig tries .jsonc if .json is missing', () => {
+    const jsoncPath = join(tmpDir, 'test.jsonc');
+    writeFileSync(jsoncPath, '{"a": 1}');
+
+    // We pass .json path, it should try .jsonc
+    const result = parseConfig(join(tmpDir, 'test.json'));
+    expect(result.config).toEqual({ a: 1 } as any);
+  });
+
+  test('writeConfig writes JSON and creates backup', () => {
+    const path = join(tmpDir, 'test.json');
+    writeFileSync(path, '{"old": true}');
+
+    writeConfig(path, { new: true } as any);
+
+    expect(JSON.parse(readFileSync(path, 'utf-8'))).toEqual({ new: true });
+    expect(JSON.parse(readFileSync(`${path}.bak`, 'utf-8'))).toEqual({
+      old: true,
+    });
+  });
+
+  test('addPluginToOpenCodeConfig adds plugin and removes duplicates', async () => {
+    const configPath = join(tmpDir, 'opencode', 'opencode.json');
+    paths.ensureConfigDir();
+    writeFileSync(
+      configPath,
+      JSON.stringify({ plugin: ['other', 'opencode-dux@1.0.0'] }),
+    );
+    process.argv[1] = '';
+
+    const result = await addPluginToOpenCodeConfig();
+    expect(result.success).toBe(true);
+
+    const saved = JSON.parse(readFileSync(configPath, 'utf-8'));
+    expect(saved.plugin).toContain('opencode-dux');
+    expect(saved.plugin).not.toContain('opencode-dux@1.0.0');
+    expect(saved.plugin.length).toBe(2);
+  });
+
+  test('addPluginToOpenCodeConfig stores package name for bunx temp paths', async () => {
+    const configPath = join(tmpDir, 'opencode', 'opencode.json');
+    const packageRoot = join(
+      tmpDir,
+      'bunx-1000-opencode-dux@latest',
+      'node_modules',
+      'opencode-dux',
+    );
+    paths.ensureConfigDir();
+    writeFileSync(configPath, JSON.stringify({ plugin: [] }));
+    writePackageJson(packageRoot);
+    process.argv[1] = join(packageRoot, 'dist', 'cli', 'index.js');
+
+    const result = await addPluginToOpenCodeConfig();
+
+    expect(result.success).toBe(true);
+    const saved = JSON.parse(readFileSync(configPath, 'utf-8'));
+    expect(saved.plugin).toEqual(['opencode-dux']);
+  });
+
+  test('addPluginToOpenCodeConfig stores local repo path for local dev paths', async () => {
+    const configPath = join(tmpDir, 'opencode', 'opencode.json');
+    const packageRoot = join(tmpDir, 'repo');
+    const localCliPath = join(packageRoot, 'dist', 'cli', 'index.js');
+    paths.ensureConfigDir();
+    writeFileSync(configPath, JSON.stringify({ plugin: [] }));
+    writePackageJson(packageRoot);
+    process.argv[1] = localCliPath;
+
+    const result = await addPluginToOpenCodeConfig();
+
+    expect(result.success).toBe(true);
+    const saved = JSON.parse(readFileSync(configPath, 'utf-8'));
+    expect(saved.plugin).toEqual([packageRoot]);
+  });
+
+  test('addPluginToOpenCodeConfig stores local repo path for local paths containing bunx-', async () => {
+    const configPath = join(tmpDir, 'opencode', 'opencode.json');
+    const packageRoot = join(tmpDir, 'repo', 'bunx-tools');
+    const localCliPath = join(packageRoot, 'dist', 'cli', 'index.js');
+    paths.ensureConfigDir();
+    writeFileSync(configPath, JSON.stringify({ plugin: [] }));
+    writePackageJson(packageRoot);
+    process.argv[1] = localCliPath;
+
+    const result = await addPluginToOpenCodeConfig();
+
+    expect(result.success).toBe(true);
+    const saved = JSON.parse(readFileSync(configPath, 'utf-8'));
+    expect(saved.plugin).toEqual([packageRoot]);
+  });
+
+  test('addPluginToOpenCodeConfig deduplicates existing local repo path entries', async () => {
+    const configPath = join(tmpDir, 'opencode', 'opencode.json');
+    const packageRoot = join(tmpDir, 'repo');
+    const localCliPath = join(packageRoot, 'dist', 'cli', 'index.js');
+    paths.ensureConfigDir();
+    writePackageJson(packageRoot);
+    writeFileSync(
+      configPath,
+      JSON.stringify({ plugin: ['other', packageRoot] }),
+    );
+    process.argv[1] = localCliPath;
+
+    const result = await addPluginToOpenCodeConfig();
+
+    expect(result.success).toBe(true);
+    const saved = JSON.parse(readFileSync(configPath, 'utf-8'));
+    expect(saved.plugin).toEqual(['other', packageRoot]);
+  });
+
+  test('addPluginToOpenCodeConfig preserves non-string plugin entries when refreshing', async () => {
+    const configPath = join(tmpDir, 'opencode', 'opencode.json');
+    paths.ensureConfigDir();
+    process.argv[1] = '';
+
+    const objectPlugin = { name: 'some-config-plugin', enabled: true };
+    writeFileSync(
+      configPath,
+      JSON.stringify({
+        plugin: ['other-plugin', objectPlugin, 'opencode-dux@1.0.0'],
+      }),
+    );
+
+    const result = await addPluginToOpenCodeConfig();
+    expect(result.success).toBe(true);
+
+    const saved = JSON.parse(readFileSync(configPath, 'utf-8'));
+    expect(saved.plugin).toContain('opencode-dux');
+    expect(saved.plugin).toContain('other-plugin');
+    expect(saved.plugin).not.toContain('opencode-dux@1.0.0');
+    // Non-string entries (objects) must survive the plugin refresh
+    expect(saved.plugin).toContainEqual(objectPlugin);
+    expect(saved.plugin.length).toBe(3);
+  });
+
+  test('addPluginToOpenCodeConfig removes tuple plugin entries', async () => {
+    const configPath = join(tmpDir, 'opencode', 'opencode.json');
+    paths.ensureConfigDir();
+    writeFileSync(
+      configPath,
+      JSON.stringify({
+        plugin: ['other', ['opencode-dux', { enabled: true }]],
+      }),
+    );
+    process.argv[1] = '';
+
+    const result = await addPluginToOpenCodeConfig();
+    expect(result.success).toBe(true);
+
+    const saved = JSON.parse(readFileSync(configPath, 'utf-8'));
+    expect(saved.plugin).toEqual(['other', 'opencode-dux']);
+  });
+
+  test('addPluginToOpenCodeTuiConfig adds plugin to tui.json and removes duplicates', async () => {
+    const tuiPath = join(tmpDir, 'opencode', 'tui.json');
+    paths.ensureConfigDir();
+    writeFileSync(
+      tuiPath,
+      JSON.stringify({ plugin: ['other', 'opencode-dux@1.0.0'] }),
+    );
+    process.argv[1] = '';
+
+    const result = await addPluginToOpenCodeTuiConfig();
+    expect(result.success).toBe(true);
+
+    const saved = JSON.parse(readFileSync(tuiPath, 'utf-8'));
+    expect(saved.plugin).toContain('opencode-dux');
+    expect(saved.plugin).not.toContain('opencode-dux@1.0.0');
+    expect(saved.plugin.length).toBe(2);
+  });
+
+  test('addPluginToOpenCodeTuiConfig stores package name for bunx temp paths', async () => {
+    const tuiPath = join(tmpDir, 'opencode', 'tui.json');
+    const packageRoot = join(
+      tmpDir,
+      'bunx-1000-opencode-dux@latest',
+      'node_modules',
+      'opencode-dux',
+    );
+    paths.ensureConfigDir();
+    writeFileSync(tuiPath, JSON.stringify({ plugin: [] }));
+    writePackageJson(packageRoot);
+    process.argv[1] = join(packageRoot, 'dist', 'cli', 'index.js');
+
+    const result = await addPluginToOpenCodeTuiConfig();
+
+    expect(result.success).toBe(true);
+    const saved = JSON.parse(readFileSync(tuiPath, 'utf-8'));
+    expect(saved.plugin).toEqual(['opencode-dux']);
+  });
+
+  test('addPluginToOpenCodeTuiConfig removes tuple plugin entries', async () => {
+    const tuiPath = join(tmpDir, 'opencode', 'tui.json');
+    paths.ensureConfigDir();
+    writeFileSync(
+      tuiPath,
+      JSON.stringify({
+        plugin: ['other', ['opencode-dux', { enabled: true }]],
+      }),
+    );
+    process.argv[1] = '';
+
+    const result = await addPluginToOpenCodeTuiConfig();
+    expect(result.success).toBe(true);
+
+    const saved = JSON.parse(readFileSync(tuiPath, 'utf-8'));
+    expect(saved.plugin).toEqual(['other', 'opencode-dux']);
+  });
+
+  test('addPluginToOpenCodeTuiConfig honors OPENCODE_TUI_CONFIG', async () => {
+    const tuiPath = join(tmpDir, 'custom', 'tui.custom.json');
+    process.env.OPENCODE_TUI_CONFIG = tuiPath;
+    process.argv[1] = '';
+
+    const result = await addPluginToOpenCodeTuiConfig();
+    expect(result.success).toBe(true);
+    expect(result.configPath).toBe(tuiPath);
+
+    const saved = JSON.parse(readFileSync(tuiPath, 'utf-8'));
+    expect(saved.plugin).toEqual(['opencode-dux']);
+  });
+
+  test('addPluginToOpenCodeTuiConfig does not bypass OPENCODE_TUI_CONFIG for existing default config', async () => {
+    const defaultTuiPath = join(tmpDir, 'opencode', 'tui.jsonc');
+    const customTuiPath = join(tmpDir, 'custom', 'tui.json');
+    paths.ensureConfigDir();
+    writeFileSync(defaultTuiPath, JSON.stringify({ plugin: ['default'] }));
+    process.env.OPENCODE_TUI_CONFIG = customTuiPath;
+    process.argv[1] = '';
+
+    const result = await addPluginToOpenCodeTuiConfig();
+    expect(result.success).toBe(true);
+    expect(result.configPath).toBe(customTuiPath);
+
+    const custom = JSON.parse(readFileSync(customTuiPath, 'utf-8'));
+    const original = JSON.parse(readFileSync(defaultTuiPath, 'utf-8'));
+    expect(custom.plugin).toEqual(['opencode-dux']);
+    expect(original.plugin).toEqual(['default']);
+  });
+
+  test('addPluginToOpenCodeTuiConfig stores local repo path for local dev paths', async () => {
+    const tuiPath = join(tmpDir, 'opencode', 'tui.json');
+    const packageRoot = join(tmpDir, 'repo');
+    const localCliPath = join(packageRoot, 'dist', 'cli', 'index.js');
+    paths.ensureConfigDir();
+    writeFileSync(tuiPath, JSON.stringify({ plugin: [] }));
+    writePackageJson(packageRoot);
+    process.argv[1] = localCliPath;
+
+    const result = await addPluginToOpenCodeTuiConfig();
+
+    expect(result.success).toBe(true);
+    const saved = JSON.parse(readFileSync(tuiPath, 'utf-8'));
+    expect(saved.plugin).toEqual([packageRoot]);
+  });
+
+  test('addPluginToOpenCodeTuiConfig deduplicates existing local repo path entries', async () => {
+    const tuiPath = join(tmpDir, 'opencode', 'tui.json');
+    const packageRoot = join(tmpDir, 'repo');
+    const localCliPath = join(packageRoot, 'dist', 'cli', 'index.js');
+    paths.ensureConfigDir();
+    writePackageJson(packageRoot);
+    writeFileSync(tuiPath, JSON.stringify({ plugin: ['other', packageRoot] }));
+    process.argv[1] = localCliPath;
+
+    const result = await addPluginToOpenCodeTuiConfig();
+
+    expect(result.success).toBe(true);
+    const saved = JSON.parse(readFileSync(tuiPath, 'utf-8'));
+    expect(saved.plugin).toEqual(['other', packageRoot]);
+  });
+
+  test('addPluginToOpenCodeTuiConfig preserves non-string plugin entries when refreshing', async () => {
+    const tuiPath = join(tmpDir, 'opencode', 'tui.json');
+    paths.ensureConfigDir();
+    process.argv[1] = '';
+
+    const objectPlugin = { name: 'some-tui-plugin', enabled: true };
+    writeFileSync(
+      tuiPath,
+      JSON.stringify({
+        plugin: ['other-plugin', objectPlugin, 'opencode-dux@1.0.0'],
+      }),
+    );
+
+    const result = await addPluginToOpenCodeTuiConfig();
+    expect(result.success).toBe(true);
+
+    const saved = JSON.parse(readFileSync(tuiPath, 'utf-8'));
+    expect(saved.plugin).toContain('opencode-dux');
+    expect(saved.plugin).toContain('other-plugin');
+    expect(saved.plugin).not.toContain('opencode-dux@1.0.0');
+    // Non-string entries (objects) must survive the plugin refresh
+    expect(saved.plugin).toContainEqual(objectPlugin);
+    expect(saved.plugin.length).toBe(3);
+  });
+
+  test('writeLiteConfig writes lite config with OpenAI preset', () => {
+    const litePath = join(tmpDir, 'opencode', 'opencode-dux.json');
+    paths.ensureConfigDir();
+
+    const result = writeLiteConfig({
+      installSkills: false,
+      installCustomSkills: false,
+      reset: false,
+    });
+    expect(result.success).toBe(true);
+
+    const saved = JSON.parse(readFileSync(litePath, 'utf-8'));
+    expect(saved.$schema).toBe(
+      'https://unpkg.com/opencode-dux@latest/opencode-dux.schema.json',
+    );
+    expect(saved.preset).toBe('openai');
+    expect(saved.presets.openai).toBeDefined();
+    expect(saved.presets['opencode-go']).toBeDefined();
+  });
+
+  test('writeLiteConfig writes selected preset', () => {
+    const litePath = join(tmpDir, 'opencode', 'opencode-dux.json');
+    paths.ensureConfigDir();
+
+    const result = writeLiteConfig({
+      installSkills: false,
+      installCustomSkills: false,
+      preset: 'opencode-go',
+      reset: false,
+    });
+    expect(result.success).toBe(true);
+
+    const saved = JSON.parse(readFileSync(litePath, 'utf-8'));
+    expect(saved.preset).toBe('opencode-go');
+    expect(saved.presets.openai).toBeDefined();
+    expect(saved.presets['opencode-go'].orchestrator.model).toBe(
+      'neuralwatt/zai-org/GLM-5.1-FP8',
+    );
+  });
+
+  test('disableDefaultAgents disables explore and general agents', () => {
+    const configPath = join(tmpDir, 'opencode', 'opencode.json');
+    paths.ensureConfigDir();
+    writeFileSync(configPath, JSON.stringify({}));
+
+    const result = disableDefaultAgents();
+    expect(result.success).toBe(true);
+
+    const saved = JSON.parse(readFileSync(configPath, 'utf-8'));
+    expect(saved.agent.explore.disable).toBe(true);
+    expect(saved.agent.general.disable).toBe(true);
+  });
+
+  test('enableLspByDefault sets lsp true when missing', () => {
+    const configPath = join(tmpDir, 'opencode', 'opencode.json');
+    paths.ensureConfigDir();
+    writeFileSync(configPath, JSON.stringify({ plugin: ['other'] }));
+
+    const result = enableLspByDefault();
+    expect(result.success).toBe(true);
+
+    const saved = JSON.parse(readFileSync(configPath, 'utf-8'));
+    expect(saved.lsp).toBe(true);
+    expect(saved.plugin).toEqual(['other']);
+  });
+
+  test('enableLspByDefault preserves explicit lsp config', () => {
+    const configPath = join(tmpDir, 'opencode', 'opencode.json');
+    paths.ensureConfigDir();
+    writeFileSync(configPath, JSON.stringify({ lsp: false }));
+
+    const result = enableLspByDefault();
+    expect(result.success).toBe(true);
+
+    const saved = JSON.parse(readFileSync(configPath, 'utf-8'));
+    expect(saved.lsp).toBe(false);
+  });
+
+  test('enableLspByDefault does not write when lsp exists', () => {
+    const configPath = join(tmpDir, 'opencode', 'opencode.json');
+    paths.ensureConfigDir();
+    writeFileSync(configPath, JSON.stringify({ lsp: false }));
+
+    const result = enableLspByDefault();
+    expect(result.success).toBe(true);
+
+    expect(existsSync(`${configPath}.bak`)).toBe(false);
+  });
+
+  test('detectCurrentConfig detects installed status', () => {
+    const configPath = join(tmpDir, 'opencode', 'opencode.json');
+    const litePath = join(tmpDir, 'opencode', 'opencode-dux.json');
+    paths.ensureConfigDir();
+
+    writeFileSync(
+      configPath,
+      JSON.stringify({
+        plugin: ['opencode-dux'],
+        provider: {
+          kimi: {
+            npm: '@ai-sdk/openai-compatible',
+          },
+        },
+      }),
+    );
+    writeFileSync(
+      litePath,
+      JSON.stringify({
+        preset: 'openai',
+        presets: {
+          openai: {
+            orchestrator: { model: 'openai/gpt-4' },
+            oracle: { model: 'anthropic/claude-opus-4-6' },
+            explorer: { model: 'github-copilot/grok-code-fast-1' },
+            librarian: { model: 'zai-coding-plan/glm-4.7' },
+          },
+        },
+      }),
+    );
+
+    const detected = detectCurrentConfig();
+    expect(detected.isInstalled).toBe(true);
+    expect(detected.hasKimi).toBe(true);
+    expect(detected.hasOpenAI).toBe(true);
+    expect(detected.hasAnthropic).toBe(true);
+    expect(detected.hasCopilot).toBe(true);
+    expect(detected.hasZaiPlan).toBe(true);
+  });
+
+  test('detectCurrentConfig treats local repo path entries as installed', () => {
+    const configPath = join(tmpDir, 'opencode', 'opencode.json');
+    const packageRoot = join(tmpDir, 'repo');
+    paths.ensureConfigDir();
+    writePackageJson(packageRoot);
+    writeFileSync(configPath, JSON.stringify({ plugin: [packageRoot] }));
+
+    const detected = detectCurrentConfig();
+
+    expect(detected.isInstalled).toBe(true);
+  });
+});