Merge pull request #420 from ReqX/fix/351-preset-runtime-reinit

fix(preset): persist runtime preset across plugin re-inits

Author: alvinunreal

docs/preset-switching.md

@@ -13,7 +13,9 @@ Switch agent model presets at runtime without restarting OpenCode using the `/pr
 
 1. Define named presets in `oh-my-opencode-slim.jsonc` under the `presets` field
 2. Run `/preset <name>` to switch. The plugin calls the OpenCode SDK's `config.update()` method, which triggers a server-side cache invalidation
-3. The next LLM call uses the new models and settings
+3. Agents covered by the new preset get the preset's values
+4. Agents that were in the *previous* preset but are *not* in the new one are reset to their config-file baseline values
+5. The next LLM call uses the new models and settings
 
 ## Example Configuration
 
@@ -61,9 +63,9 @@ There are two ways to activate a preset:
 | Method | How | Persists? |
 |--------|-----|-----------|
 | Config file | Set `"preset": "cheap"` in `oh-my-opencode-slim.jsonc` | Yes, across restarts |
-| `/preset` command | Run `/preset cheap` during a session | No, reverts on restart |
+| `/preset` command | Run `/preset cheap` during a session | Across re-inits, not restarts |
 
-On restart, the plugin's `config()` hook re-applies the preset from the config file, overwriting any runtime switch. To make a runtime switch permanent, update the `"preset"` field in your config file.
+Runtime preset switches persist across plugin re-inits (triggered by config changes, etc.) within the same process, but revert on process restart. On restart, the plugin applies the preset from the config file. To make a runtime switch permanent, update the `"preset"` field in your config file.
 
 ## Example Output
 
@@ -92,6 +94,11 @@ Usage: /preset <name> to switch.
 Switched to preset "powerful":
 orchestrator → model: openai/gpt-5.5
 oracle → model: anthropic/claude-opus-4-6
+Reset to baseline: explorer
 ```
 
+The "Reset to baseline" line appears when agents from the previous preset
+are not present in the new one. Those agents are reverted to their
+config-file defaults.
+
 > See [Configuration](configuration.md) for the full preset option reference.

src/config/index.ts

@@ -1,5 +1,5 @@
 export * from './constants';
 export * from './council-schema';
-export { loadAgentPrompt, loadPluginConfig } from './loader';
+export { deepMerge, loadAgentPrompt, loadPluginConfig } from './loader';
 export * from './schema';
 export { getAgentOverride, getCustomAgentNames } from './utils';

src/config/loader.ts

@@ -88,7 +88,7 @@ function findConfigPathInDirs(
  * @param override - Override object whose values take precedence
  * @returns Merged object, or undefined if both inputs are undefined
  */
-function deepMerge<T extends Record<string, unknown>>(
+export function deepMerge<T extends Record<string, unknown>>(
   base?: T,
   override?: T,
 ): T | undefined {

src/config/runtime-preset.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, test } from 'bun:test';
+import {
+  getActiveRuntimePreset,
+  getPreviousRuntimePreset,
+  rollbackRuntimePreset,
+  setActiveRuntimePreset,
+  setActiveRuntimePresetWithPrevious,
+} from './runtime-preset';
+
+describe('runtime-preset', () => {
+  // Cleanup after each test to avoid state leakage
+  test('getActiveRuntimePreset returns null initially', () => {
+    setActiveRuntimePreset(null);
+    expect(getActiveRuntimePreset()).toBeNull();
+    setActiveRuntimePreset(null);
+  });
+
+  test('setActiveRuntimePreset sets the active preset', () => {
+    setActiveRuntimePreset(null);
+    setActiveRuntimePreset('foo');
+    expect(getActiveRuntimePreset()).toBe('foo');
+    setActiveRuntimePreset(null);
+  });
+
+  test('setActiveRuntimePresetWithPrevious sets active and previous', () => {
+    setActiveRuntimePreset(null);
+    setActiveRuntimePreset('old');
+    setActiveRuntimePresetWithPrevious('new');
+    expect(getActiveRuntimePreset()).toBe('new');
+    expect(getPreviousRuntimePreset()).toBe('old');
+    setActiveRuntimePreset(null);
+  });
+
+  test('setActiveRuntimePresetWithPrevious with null sets previous to old', () => {
+    setActiveRuntimePreset(null);
+    setActiveRuntimePreset('old');
+    setActiveRuntimePresetWithPrevious(null);
+    expect(getActiveRuntimePreset()).toBeNull();
+    expect(getPreviousRuntimePreset()).toBe('old');
+    setActiveRuntimePreset(null);
+  });
+
+  test('rollbackRuntimePreset restores active and clears previous', () => {
+    setActiveRuntimePreset(null);
+    setActiveRuntimePreset('old');
+    setActiveRuntimePresetWithPrevious('new');
+    rollbackRuntimePreset('old');
+    expect(getActiveRuntimePreset()).toBe('old');
+    expect(getPreviousRuntimePreset()).toBeNull();
+    setActiveRuntimePreset(null);
+  });
+
+  test('rollbackRuntimePreset with null clears active and previous', () => {
+    setActiveRuntimePreset(null);
+    setActiveRuntimePresetWithPrevious('new');
+    rollbackRuntimePreset(null);
+    expect(getActiveRuntimePreset()).toBeNull();
+    expect(getPreviousRuntimePreset()).toBeNull();
+    setActiveRuntimePreset(null);
+  });
+});

src/config/runtime-preset.ts

@@ -0,0 +1,37 @@
+/**
+ * Module-level runtime preset state.
+ *
+ * Survives plugin re-inits triggered by client.config.update() →
+ * Instance.dispose(). The plugin function re-runs but this module-level
+ * variable persists within the same Node.js process.
+ */
+
+let activeRuntimePreset: string | null = null;
+
+export function setActiveRuntimePreset(name: string | null): void {
+  activeRuntimePreset = name;
+}
+
+export function getActiveRuntimePreset(): string | null {
+  return activeRuntimePreset;
+}
+
+/**
+ * Returns the name of the previously active runtime preset (before the
+ * current one), used to compute reset diffs when switching presets.
+ */
+let previousRuntimePreset: string | null = null;
+
+export function getPreviousRuntimePreset(): string | null {
+  return previousRuntimePreset;
+}
+
+export function setActiveRuntimePresetWithPrevious(name: string | null): void {
+  previousRuntimePreset = activeRuntimePreset;
+  activeRuntimePreset = name;
+}
+
+export function rollbackRuntimePreset(previous: string | null): void {
+  activeRuntimePreset = previous;
+  previousRuntimePreset = null;
+}

src/index.ts

@@ -1,8 +1,19 @@
 import type { Plugin } from '@opencode-ai/plugin';
 import { createAgents, getAgentConfigs, getDisabledAgents } from './agents';
 import { buildOrchestratorPrompt } from './agents/orchestrator';
-import { loadPluginConfig, type MultiplexerConfig } from './config';
+import {
+  type AgentOverrideConfig,
+  deepMerge,
+  loadPluginConfig,
+  type MultiplexerConfig,
+} from './config';
+import { AGENT_ALIASES } from './config/constants';
 import { parseList } from './config/agent-mcps';
+import {
+  getActiveRuntimePreset,
+  getPreviousRuntimePreset,
+  setActiveRuntimePreset,
+} from './config/runtime-preset';
 import { CouncilManager } from './council';
 import {
   createApplyPatchHook,
@@ -85,6 +96,11 @@ async function probeJSDOM(): Promise<string | null> {
   }
 }
 
+// Module-level runtime preset tracking. Survives plugin re-inits triggered
+// by client.config.update() → Instance.dispose(). When the plugin function
+// re-runs, it checks this variable and applies the runtime preset instead
+// of the config file's preset. State lives in config/runtime-preset.ts.
+
 const OhMyOpenCodeLite: Plugin = async (ctx) => {
   const sessionId = new Date().toISOString().replace(/[-:]/g, '').slice(0, 15);
   initLogger(sessionId);
@@ -129,6 +145,25 @@ const OhMyOpenCodeLite: Plugin = async (ctx) => {
 
   try {
     config = loadPluginConfig(ctx.directory);
+
+    // Safety net: if a runtime preset was set via /preset command and
+    // OpenCode ever fully re-runs the plugin function (not just the
+    // config() hook), override config.preset so agents are created with
+    // the correct models. Currently only the config() hook re-runs after
+    // Instance.dispose(), so this is a defensive guard.
+    const runtimePreset = getActiveRuntimePreset();
+    if (runtimePreset && config.presets?.[runtimePreset]) {
+      config.preset = runtimePreset;
+      // Re-merge runtime preset into config.agents (loadPluginConfig
+      // already merged the config-file preset, not the runtime one).
+      // Runtime preset is override so it wins over config-file preset.
+      const presetAgents = config.presets[runtimePreset];
+      config.agents = deepMerge(config.agents, presetAgents);
+    } else if (runtimePreset) {
+      // Preset was deleted from config since last switch — clear stale state
+      setActiveRuntimePreset(null);
+    }
+
     disabledAgents = getDisabledAgents(config);
     rewriteDisplayNameMentions = createDisplayNameMentionRewriter(config);
     agentDefs = createAgents(config);
@@ -472,6 +507,136 @@ const OhMyOpenCodeLite: Plugin = async (ctx) => {
         }
       }
 
+      // Runtime preset override: if /preset switched to a runtime preset,
+      // override the model/variant/temperature from the preset's agent
+      // config. This runs after the normal model resolution because the
+      // config() hook re-runs with stale modelArrayMap after dispose(),
+      // but the runtime preset data is in the captured `config` closure.
+      const runtimePresetName = getActiveRuntimePreset();
+      if (runtimePresetName && config.presets?.[runtimePresetName]) {
+        const runtimePreset = config.presets[runtimePresetName];
+        for (const [agentName, override] of Object.entries(runtimePreset)) {
+          // Resolve legacy alias keys (e.g. "explore" → "explorer")
+          // so presets using aliases work in this path.
+          const resolvedName = AGENT_ALIASES[agentName] ?? agentName;
+          const entry = configAgent[resolvedName] as
+            | Record<string, unknown>
+            | undefined;
+          if (!entry) continue;
+
+          if (typeof override.model === 'string') {
+            entry.model = override.model;
+          } else if (
+            Array.isArray(override.model) &&
+            override.model.length > 0
+          ) {
+            const first = override.model[0];
+            entry.model = typeof first === 'string' ? first : first.id;
+            // Extract inline variant from array-form model entry
+            if (typeof first !== 'string' && first.variant) {
+              entry.variant = first.variant;
+            }
+          }
+          // Explicitly set or clear scalar fields so switching from
+          // Preset A (which sets a field) to Preset B (which doesn't)
+          // doesn't leave stale values behind.
+          if (typeof override.variant === 'string') {
+            entry.variant = override.variant;
+          } else if ('variant' in override) {
+            delete entry.variant;
+          }
+          if (typeof override.temperature === 'number') {
+            entry.temperature = override.temperature;
+          } else if ('temperature' in override) {
+            delete entry.temperature;
+          }
+          if (
+            override.options &&
+            typeof override.options === 'object' &&
+            !Array.isArray(override.options)
+          ) {
+            entry.options = override.options;
+          } else if ('options' in override) {
+            delete entry.options;
+          }
+          log('[plugin] runtime preset override', {
+            preset: runtimePresetName,
+            agent: agentName,
+            model: entry.model as string,
+          });
+        }
+
+        // Reset agents from the previous preset that aren't in the new one.
+        // The stale model resolution above overwrites the reset values sent
+        // by preset-manager, so we re-apply them here from config-file
+        // baseline.
+        const prevPresetName = getPreviousRuntimePreset();
+        if (prevPresetName && config.presets?.[prevPresetName]) {
+          const prevPreset = config.presets[prevPresetName];
+          // Build resolved key set from new preset for correct comparison
+          // (handles alias keys like "explore" → "explorer")
+          const newPresetResolved = new Set(
+            Object.keys(runtimePreset).map(
+              (k) => AGENT_ALIASES[k] ?? k,
+            ),
+          );
+          for (const agentName of Object.keys(prevPreset)) {
+            const resolvedName =
+              AGENT_ALIASES[agentName] ?? agentName;
+            if (newPresetResolved.has(resolvedName))
+              continue; // new preset handles it
+            const entry = configAgent[resolvedName] as
+              | Record<string, unknown>
+              | undefined;
+            if (!entry) continue;
+            // Reset to config-file baseline. Use the previous preset's
+            // override to identify which fields to clear even when the
+            // baseline doesn't define them.
+            const baseline =
+              config.agents?.[resolvedName];
+            const prevOverride = prevPreset[agentName] as
+              | AgentOverrideConfig
+              | undefined;
+            if (typeof baseline?.model === 'string') {
+              entry.model = baseline.model;
+            }
+            if (typeof baseline?.variant === 'string') {
+              entry.variant = baseline.variant;
+            } else if (
+              prevOverride &&
+              'variant' in prevOverride
+            ) {
+              delete entry.variant;
+            }
+            if (typeof baseline?.temperature === 'number') {
+              entry.temperature = baseline.temperature;
+            } else if (
+              prevOverride &&
+              'temperature' in prevOverride
+            ) {
+              delete entry.temperature;
+            }
+            if (
+              baseline?.options &&
+              typeof baseline.options === 'object' &&
+              !Array.isArray(baseline.options)
+            ) {
+              entry.options = baseline.options;
+            } else if (
+              prevOverride &&
+              'options' in prevOverride
+            ) {
+              delete entry.options;
+            }
+            log('[plugin] runtime preset reset from previous', {
+              previousPreset: prevPresetName,
+              agent: resolvedName,
+              model: entry.model as string,
+            });
+          }
+        }
+      }
+
       // Merge MCP configs
       const configMcp = opencodeConfig.mcp as
         | Record<string, unknown>