@openchambery/web 1.19.22-beta.1 → 2.0.0-beta.3

package/server/lib/opencode/agent-document.test.js

@@ -0,0 +1,137 @@
+import { describe, expect, it } from 'vitest';
+
+import { applyNativePatch, convertAgentConfig, inspectAgentConfig, writeAgentDocument } from './agent-document.js';
+
+describe('inspectAgentConfig', () => {
+  it('treats a native file as current', () => {
+    expect(inspectAgentConfig({
+      description: 'Reviewer',
+      mode: 'subagent',
+      model: 'openai/gpt-5#high',
+      hidden: true,
+      color: '#ff6b6b',
+      steps: 5,
+      permissions: [{ action: 'shell', resource: '*', effect: 'ask' }],
+    })).toEqual({ legacy: false, dropped: [] });
+  });
+
+  it('reports fields the next request does not use', () => {
+    const inspection = inspectAgentConfig({
+      temperature: 0.2,
+      top_p: 0.9,
+      options: { reasoningEffort: 'high' },
+      prompt: '{file:./prompt.md}',
+      color: 'red',
+      variant: 'high',
+      extra: true,
+    });
+    expect(inspection.legacy).toBe(true);
+    expect(inspection.dropped).toEqual([
+      { key: 'temperature', reason: 'generation' },
+      { key: 'top_p', reason: 'generation' },
+      { key: 'options', reason: 'unknown' },
+      { key: 'prompt', reason: 'prompt-file' },
+      { key: 'color', reason: 'color' },
+      { key: 'variant', reason: 'variant' },
+      { key: 'extra', reason: 'unknown' },
+    ]);
+  });
+});
+
+describe('convertAgentConfig', () => {
+  it('folds a legacy agent into native markdown fields', () => {
+    const converted = convertAgentConfig({
+      description: 'Reviewer',
+      mode: 'subagent',
+      model: 'openai/gpt-5',
+      variant: 'high',
+      temperature: 0.2,
+      prompt: 'Be careful.',
+      permission: { bash: 'ask', task: 'allow', write: 'deny' },
+      tools: { write: false },
+      maxSteps: 4,
+      disable: true,
+      color: '#112233',
+      request: { body: { temperature: 0.2 } },
+    });
+
+    expect(converted.legacy).toBe(true);
+    expect(converted.body).toBe('Be careful.');
+    expect(converted.frontmatter).toMatchObject({
+      description: 'Reviewer',
+      mode: 'subagent',
+      model: 'openai/gpt-5#high',
+      steps: 4,
+      disabled: true,
+      color: '#112233',
+      request: { body: { temperature: 0.2 } },
+    });
+    expect(converted.frontmatter).not.toHaveProperty('temperature');
+    expect(converted.frontmatter).not.toHaveProperty('hidden');
+    expect(converted.frontmatter.permissions).toEqual(expect.arrayContaining([
+      { action: 'shell', resource: '*', effect: 'ask' },
+      { action: 'subagent', resource: '*', effect: 'allow' },
+      { action: 'edit', resource: '*', effect: 'deny' },
+    ]));
+  });
+});
+
+describe('applyNativePatch', () => {
+  it('patches only the keys present in the update', () => {
+    const next = applyNativePatch({
+      frontmatter: {
+        model: 'openai/gpt-5',
+        hidden: true,
+        permissions: [{ action: 'read', resource: '*', effect: 'allow' }],
+        variant: 'high',
+        temperature: 1,
+      },
+      body: 'old',
+    }, {
+      model: null,
+      hidden: false,
+      permissions: [],
+      system: null,
+      steps: 0,
+    });
+
+    expect(next.body).toBe('');
+    expect(next.frontmatter).toEqual({
+      temperature: 1,
+    });
+  });
+});
+
+describe('writeAgentDocument', () => {
+  it('leaves unmentioned fields alone on a prompt-only patch', () => {
+    const next = writeAgentDocument({
+      frontmatter: {
+        temperature: 1,
+        permission: { bash: 'allow' },
+      },
+      body: 'legacy prompt',
+    }, {
+      system: 'Only the prompt changed.',
+    }, false);
+
+    expect(next.body).toBe('Only the prompt changed.');
+    expect(next.frontmatter.temperature).toBe(1);
+    expect(next.frontmatter.permission).toEqual({ bash: 'allow' });
+  });
+
+  it('drops legacy fields when confirmDrop is true', () => {
+    const next = writeAgentDocument({
+      frontmatter: {
+        temperature: 1,
+        permission: { bash: 'allow' },
+      },
+      body: 'legacy prompt',
+    }, {
+      system: 'Only the prompt changed.',
+    }, true);
+
+    expect(next.body).toBe('Only the prompt changed.');
+    expect(next.frontmatter.temperature).toBeUndefined();
+    expect(next.frontmatter.permission).toEqual({ bash: 'allow' });
+  });
+});

package/server/lib/opencode/agents.js

@@ -16,6 +16,10 @@ import {
   resolvePromptFilePath,
   writePromptFile,
 } from './shared.js';
+import {
+  inspectAgentConfig,
+  writeAgentDocument,
+} from './agent-document.js';
 
 // ============== AGENT SCOPE HELPERS ==============
 
@@ -321,21 +325,100 @@ function getAgentSources(agentName, workingDirectory, lookupCache = createAgentL
     }
   };
 
+  const stored = {};
+  if (jsonSection && typeof jsonSection === 'object') {
+    Object.assign(stored, jsonSection);
+  }
   if (mdExists) {
     const { frontmatter, body } = parseMdFile(mdPath);
     sources.md.fields = Object.keys(frontmatter);
     if (body) {
       sources.md.fields.push('prompt');
     }
+    Object.assign(stored, frontmatter);
+    if (typeof body === 'string' && body.trim()) stored.prompt = body.trim();
   }
 
   if (jsonSection) {
     sources.json.fields = Object.keys(jsonSection);
   }
+  sources.document = inspectAgentConfig(stored);
 
   return sources;
 }
 
+function listDisabledAgentOverrides(workingDirectory) {
+  /** @type {Array<{ name: string, scope: string, description?: string, mode?: string }>} */
+  const found = [];
+  const visit = (directory, scope) => {
+    if (!directory || !fs.existsSync(directory)) return;
+    const walk = (current, prefix) => {
+      let entries = [];
+      try {
+        entries = fs.readdirSync(current, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      for (const entry of entries) {
+        if (found.length >= 200) return;
+        const full = path.join(current, entry.name);
+        if (entry.isDirectory()) {
+          walk(full, prefix ? `${prefix}/${entry.name}` : entry.name);
+          continue;
+        }
+        if (!entry.isFile() || !entry.name.endsWith('.md')) continue;
+        const base = entry.name.slice(0, -3);
+        const name = prefix ? `${prefix}/${base}` : base;
+        let frontmatter = {};
+        try {
+          frontmatter = parseMdFile(full).frontmatter || {};
+        } catch {
+          continue;
+        }
+        if (frontmatter.disabled !== true && frontmatter.disable !== true) continue;
+        found.push({
+          name,
+          scope,
+          ...(typeof frontmatter.description === 'string' ? { description: frontmatter.description } : {}),
+          ...(frontmatter.mode === 'primary' || frontmatter.mode === 'subagent' || frontmatter.mode === 'all'
+            ? { mode: frontmatter.mode }
+            : {}),
+        });
+      }
+    };
+    walk(directory, '');
+  };
+
+  visit(AGENT_DIR, AGENT_SCOPE.USER);
+  if (workingDirectory) {
+    visit(path.join(workingDirectory, '.opencode', 'agents'), AGENT_SCOPE.PROJECT);
+    visit(path.join(workingDirectory, '.opencode', 'agent'), AGENT_SCOPE.PROJECT);
+  }
+  return found;
+}
+
+function nativeWritePath(agentName, workingDirectory, scope, lookupCache) {
+  if (scope === AGENT_SCOPE.PROJECT && workingDirectory) {
+    ensureProjectAgentDir(workingDirectory);
+    return getProjectAgentPath(workingDirectory, agentName);
+  }
+  if (scope === AGENT_SCOPE.USER) {
+    return getUserAgentPath(agentName, lookupCache);
+  }
+  const existing = getAgentWritePath(agentName, workingDirectory, undefined, lookupCache);
+  if (existing.path && fs.existsSync(existing.path)) return existing.path;
+  return getUserAgentPath(agentName, lookupCache);
+}
+
+function writeNativeAgent(agentName, patch, workingDirectory, scope, confirmDrop) {
+  ensureDirs();
+  const lookupCache = createAgentLookupCache();
+  const targetPath = nativeWritePath(agentName, workingDirectory, scope, lookupCache);
+  const existing = fs.existsSync(targetPath) ? parseMdFile(targetPath) : { frontmatter: {}, body: '' };
+  const next = writeAgentDocument(existing, patch && typeof patch === 'object' ? patch : {}, confirmDrop === true);
+  writeMdFile(targetPath, next.frontmatter, next.body);
+}
+
 function getAgentConfig(agentName, workingDirectory, lookupCache = createAgentLookupCache()) {
   const projectPath = workingDirectory ? getProjectAgentPath(workingDirectory, agentName) : null;
   const projectExists = projectPath && fs.existsSync(projectPath);
@@ -409,6 +492,12 @@ function createAgent(agentName, config, workingDirectory, scope) {
     targetScope = AGENT_SCOPE.USER;
   }
 
+  if (config && Object.prototype.hasOwnProperty.call(config, 'native')) {
+    writeNativeAgent(agentName, config.native, workingDirectory, targetScope, config.confirmDrop === true);
+    console.log(`Created new agent: ${agentName} (scope: ${targetScope})`);
+    return;
+  }
+
   const { prompt, scope: _scopeFromConfig, ...rawFrontmatter } = config;
   const frontmatter = Object.fromEntries(
     Object.entries(rawFrontmatter).filter(([, value]) => value !== null && value !== undefined)
@@ -419,6 +508,12 @@ function createAgent(agentName, config, workingDirectory, scope) {
 }
 
 function updateAgent(agentName, updates, workingDirectory) {
+  if (updates && Object.prototype.hasOwnProperty.call(updates, 'native')) {
+    writeNativeAgent(agentName, updates.native, workingDirectory, updates.scope, updates.confirmDrop === true);
+    console.log(`Updated agent: ${agentName}`);
+    return;
+  }
+
   ensureDirs();
   const lookupCache = createAgentLookupCache();
 
@@ -693,6 +788,7 @@ function deleteAgent(agentName, workingDirectory, scope) {
 export {
   getAgentSources,
   getAgentConfig,
+  listDisabledAgentOverrides,
   createAgent,
   updateAgent,
   deleteAgent,

package/server/lib/opencode/auth-state-runtime.js

@@ -81,9 +81,14 @@ export const createOpenCodeAuthStateRuntime = (dependencies) => {
     return generatedPassword;
   };
 
+  // A server OpenChamber does not own (the shared official service) keeps its
+  // own password; adopt it instead of generating one.
+  const adoptOpenCodeServerPassword = (password, source) => setOpenCodeAuthState(password, source);
+
   return {
     getOpenCodeAuthHeaders,
     isOpenCodeConnectionSecure,
     ensureLocalOpenCodeServerPassword,
+    adoptOpenCodeServerPassword,
   };
 };

package/server/lib/opencode/bootstrap-runtime.js

@@ -64,6 +64,7 @@ export const createBootstrapRuntime = (dependencies) => {
       setAutoAcceptSession,
       sessionIndexService,
       sessionIndexSyncRuntime,
+      getCommittedHostMetadata = null,
       transcriptCacheService,
     } = options;
 
@@ -156,6 +157,7 @@ export const createBootstrapRuntime = (dependencies) => {
       getCachedZenModels,
       sessionIndexService,
       sessionIndexSyncRuntime,
+      getCommittedHostMetadata,
       transcriptCacheService,
       express,
     });

package/server/lib/opencode/config-entity-routes.js

@@ -2,9 +2,62 @@ import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { parse as parseJsonc } from 'jsonc-parser';
-import { createOpencodeClient } from '@opencode-ai/sdk/v2';
+import { OpenCode } from '@opencode/client';
 import { projectProviderCatalog } from './provider-catalog.js';
 
+// Compose official v2 provider.list + model.list (+ optional default) into the
+// catalog shape consumed by projectProviderCatalog. Missing arrays are failure.
+const composeV2ProviderCatalogSource = (providers, models, defaultModel) => {
+  if (!Array.isArray(providers) || !Array.isArray(models)) return null;
+
+  const modelsByProvider = new Map();
+  for (const model of models) {
+    if (!model || typeof model !== 'object') continue;
+    const providerID = typeof model.providerID === 'string' ? model.providerID : '';
+    // ModelInfo.id is the external model id used in generate/session refs.
+    // ModelInfo.modelID is a separate internal field and must not be preferred.
+    const modelID = typeof model.id === 'string' && model.id
+      ? model.id
+      : (typeof model.modelID === 'string' ? model.modelID : '');
+    if (!providerID || !modelID) continue;
+    if (!modelsByProvider.has(providerID)) modelsByProvider.set(providerID, Object.create(null));
+    const entry = { id: modelID };
+    if (typeof model.name === 'string' && model.name) entry.name = model.name;
+    if (typeof model.family === 'string' && model.family) entry.family = model.family;
+    if (model.limit && typeof model.limit === 'object') entry.limit = model.limit;
+    if (model.capabilities) entry.capabilities = model.capabilities;
+    // v2 cost is a tier array; v2 variants are `{ id }[]`. Projection owns the safe shape.
+    if (model.cost && typeof model.cost === 'object') entry.cost = model.cost;
+    if (model.variants && typeof model.variants === 'object') entry.variants = model.variants;
+    if (typeof model.time?.released === 'number' && Number.isFinite(model.time.released)) {
+      entry.release_date = new Date(model.time.released).toISOString().slice(0, 10);
+    }
+    modelsByProvider.get(providerID)[modelID] = entry;
+  }
+
+  const list = [];
+  for (const provider of providers) {
+    if (!provider || typeof provider.id !== 'string' || !provider.id) continue;
+    list.push({
+      id: provider.id,
+      name: typeof provider.name === 'string' && provider.name ? provider.name : provider.id,
+      models: modelsByProvider.get(provider.id) || Object.create(null),
+    });
+  }
+
+  const defaults = Object.create(null);
+  const defaultModelID = typeof defaultModel?.id === 'string' && defaultModel.id
+    ? defaultModel.id
+    : (typeof defaultModel?.modelID === 'string' ? defaultModel.modelID : '');
+  if (defaultModel && typeof defaultModel.providerID === 'string' && defaultModelID) {
+    defaults[defaultModel.providerID] = defaultModelID;
+  }
+  return { providers: list, default: defaults };
+};
+
+const createOpenCodeClient = ({ baseUrl, headers, fetch: fetchImpl }) =>
+  OpenCode.make({ baseUrl, headers, fetch: fetchImpl });
+
 const MAX_GLOBAL_CONFIG_SIZE = 2 * 1024 * 1024;
 const GLOBAL_CONFIG_FILES = {
   opencode: ['opencode.json', 'opencode.jsonc'],
@@ -81,10 +134,10 @@ export const registerConfigEntityRoutes = (app, dependencies) => {
   const {
     resolveProjectDirectory,
     resolveOptionalProjectDirectory,
-    refreshOpenCodeAfterConfigChange,
-    clientReloadDelayMs,
+    waitForOpenCodeReady,
     getAgentSources,
     getAgentConfig,
+    listDisabledAgentOverrides,
     createAgent,
     updateAgent,
     deleteAgent,
@@ -115,25 +168,43 @@ export const registerConfigEntityRoutes = (app, dependencies) => {
       if (!directory) {
         return res.status(400).json({ error });
       }
-      const client = createOpencodeClient({
+      // Gate on managed-OpenCode readiness like the generic proxy: without this
+      // the SDK hits an upstream that is still starting (or a stale orphan from
+      // a nodemon restart) and gets HTML/401 back, surfacing as a spurious 502.
+      if (typeof waitForOpenCodeReady === 'function') {
+        await waitForOpenCodeReady(20_000, 200);
+      }
+      const client = createOpenCodeClient({
         baseUrl: buildOpenCodeUrl('/', '').replace(/\/$/, ''),
-        directory,
         headers: getOpenCodeAuthHeaders(),
-        fetch: (request) => fetch(request, { signal: AbortSignal.timeout(8_000) }),
+        // Forward the full init: the SDK carries Authorization in init.headers.
+        // Dropping init (the old `(request) => fetch(request, { signal })` shape)
+        // silently stripped auth and produced spurious upstream 401s.
+        fetch: (request, init) => fetch(request, { ...init, signal: AbortSignal.timeout(8_000) }),
       });
-      const response = await client.config.providers({ directory });
-      if (response?.error || response?.data === undefined) {
+      const location = { directory };
+      const [providersResult, modelsResult, defaultResult] = await Promise.all([
+        client.provider.list({ location }),
+        client.model.list({ location }),
+        client.model.default({ location }),
+      ]);
+      const source = composeV2ProviderCatalogSource(
+        providersResult?.data,
+        modelsResult?.data,
+        defaultResult?.data,
+      );
+      if (!source) {
         console.error('Provider catalog upstream response failed');
         return res.status(502).json({ error: 'Provider catalog is unavailable' });
       }
-      const catalog = projectProviderCatalog(response?.data);
+      const catalog = projectProviderCatalog(source);
       if (!catalog.ok) {
         console.error('Provider catalog upstream response is malformed');
         return res.status(502).json({ error: 'Provider catalog is unavailable' });
       }
       return res.json(catalog.value);
-    } catch {
-      console.error('Provider catalog request failed');
+    } catch (catalogError) {
+      console.error('Provider catalog request failed', catalogError?.reason ? `(${catalogError.reason})` : catalogError?.message ?? catalogError);
       return res.status(502).json({ error: 'Provider catalog is unavailable' });
     }
   });
@@ -191,7 +262,8 @@ export const registerConfigEntityRoutes = (app, dependencies) => {
         target: req.params.target,
         fileName: target.fileName,
         content,
-        requiresManualRestart: true,
+        requiresManualRestart: req.params.target !== 'opencode',
+        application: req.params.target === 'opencode' ? 'watch' : 'manual',
       });
     } catch (error) {
       console.error('Failed to write global configuration:', error);
@@ -199,29 +271,9 @@ export const registerConfigEntityRoutes = (app, dependencies) => {
     }
   });
 
-  // Build the response for a config mutation based on whether OpenCode actually
-  // reloaded the change. When connected to an external OpenCode server that
-  // OpenChamber cannot restart, the change is persisted to disk but the running
-  // server will not serve it until the user restarts that server. We must not
-  // report a clean "reloading" success in that case, otherwise the UI silently
-  // reverts the edit to the stale value on the next refresh.
-  const buildConfigMutationResponse = (refreshResult, { liveMessage, manualRestartMessage }) => {
-    if (refreshResult && refreshResult.external) {
-      return {
-        success: true,
-        requiresReload: false,
-        requiresManualRestart: true,
-        message: manualRestartMessage,
-      };
-    }
-
-    return {
-      success: true,
-      requiresReload: true,
-      message: liveMessage,
-      reloadDelayMs: clientReloadDelayMs,
-    };
-  };
+  // A receipt confirms persistence, not runtime activation. V2 watches local
+  // configuration; domain events confirm changes without rebuilding locations.
+  const configSaved = () => ({ success: true, requiresReload: false, application: 'watch' });
 
   const readMutationBody = (req) => (
     req.body && typeof req.body === 'object' && !Array.isArray(req.body) ? req.body : {}
@@ -230,24 +282,7 @@ export const registerConfigEntityRoutes = (app, dependencies) => {
   const completeMcpMutation = async (res, action, name, applyChange) => {
     applyChange();
 
-    try {
-      await refreshOpenCodeAfterConfigChange(`mcp ${action}`);
-      return res.json({
-        success: true,
-        requiresReload: true,
-        message: `MCP server "${name}" ${action}d. Reloading interface…`,
-        reloadDelayMs: clientReloadDelayMs,
-      });
-    } catch (error) {
-      console.error(`[API:MCP ${action}] Reload failed after config write:`, error);
-      return res.json({
-        success: true,
-        requiresReload: false,
-        reloadFailed: true,
-        message: `MCP server "${name}" ${action}d, but OpenCode reload failed.`,
-        warning: error.message || 'OpenCode reload failed after the MCP configuration changed',
-      });
-    }
+    return res.json({ ...configSaved(), message: `MCP server "${name}" ${action}d.` });
   };
 
   app.post('/api/config/agents/metadata', async (req, res) => {
@@ -277,7 +312,10 @@ export const registerConfigEntityRoutes = (app, dependencies) => {
           sources,
         };
       }
-      return res.json({ agents });
+      const disabled = typeof listDisabledAgentOverrides === 'function'
+        ? listDisabledAgentOverrides(directory)
+        : [];
+      return res.json(disabled.length > 0 ? { agents, disabled } : { agents });
     } catch (error) {
       console.error('Failed to get agent metadata batch:', error);
       return res.status(500).json({ error: 'Failed to get agent configuration metadata' });
@@ -337,15 +375,11 @@ export const registerConfigEntityRoutes = (app, dependencies) => {
       console.log('[Server] Creating agent');
 
       createAgent(agentName, config, directory, scope);
-      const refreshResult = await refreshOpenCodeAfterConfigChange('agent creation', {
-        agentName
-      });
-
-      res.json(buildConfigMutationResponse(refreshResult, {
-        liveMessage: `Agent ${agentName} created successfully. Reloading interface…`,
-        manualRestartMessage: `Agent ${agentName} saved. Restart your connected OpenCode server to apply the change.`,
-      }));
+      res.json(configSaved());
     } catch (error) {
+      if (error?.code === 'drop-confirmation') {
+        return res.status(409).json({ code: 'drop-confirmation', dropped: error.dropped, error: error.message });
+      }
       console.error('Failed to create agent');
       res.status(500).json({ error: error.message || 'Failed to create agent' });
     }
@@ -363,15 +397,14 @@ export const registerConfigEntityRoutes = (app, dependencies) => {
       console.log('[Server] Updating agent');
 
       updateAgent(agentName, updates, directory);
-      const refreshResult = await refreshOpenCodeAfterConfigChange('agent update');
 
       console.log('[Server] Agent updated successfully');
 
-      res.json(buildConfigMutationResponse(refreshResult, {
-        liveMessage: `Agent ${agentName} updated successfully. Reloading interface…`,
-        manualRestartMessage: `Agent ${agentName} saved. Restart your connected OpenCode server to apply the change.`,
-      }));
+      res.json(configSaved());
     } catch (error) {
+      if (error?.code === 'drop-confirmation') {
+        return res.status(409).json({ code: 'drop-confirmation', dropped: error.dropped, error: error.message });
+      }
       console.error('[Server] Failed to update agent');
       res.status(500).json({ error: error.message || 'Failed to update agent' });
     }
@@ -387,12 +420,7 @@ export const registerConfigEntityRoutes = (app, dependencies) => {
 
       const scope = req.body?.scope;
       deleteAgent(agentName, directory, scope);
-      const refreshResult = await refreshOpenCodeAfterConfigChange('agent deletion');
-
-      res.json(buildConfigMutationResponse(refreshResult, {
-        liveMessage: `Agent ${agentName} deleted successfully. Reloading interface…`,
-        manualRestartMessage: `Agent ${agentName} deleted. Restart your connected OpenCode server to apply the change.`,
-      }));
+      res.json(configSaved());
     } catch (error) {
       console.error('Failed to delete agent');
       res.status(500).json({ error: error.message || 'Failed to delete agent' });
@@ -500,14 +528,17 @@ export const registerConfigEntityRoutes = (app, dependencies) => {
         if (!getOpenCodePort()) {
           return res.json({ commands: [] });
         }
-        const client = createOpencodeClient({
+        const client = createOpenCodeClient({
           baseUrl: buildOpenCodeUrl('/', '').replace(/\/$/, ''),
-          directory,
           headers: getOpenCodeAuthHeaders(),
           fetch: (request) => fetch(request, { signal: AbortSignal.timeout(8_000) }),
         });
-        const response = await client.command.list({ directory });
-        const commands = Array.isArray(response?.data) ? response.data : [];
+        const response = await client.command.list({ location: { directory } });
+        if (!Array.isArray(response?.data)) {
+          console.error('Command catalog upstream response failed');
+          return res.status(502).json({ error: 'Command catalog is unavailable' });
+        }
+        const commands = response.data;
         return res.json({
           commands: commands
             .filter((command) => command?.source !== 'skill')
@@ -598,16 +629,7 @@ export const registerConfigEntityRoutes = (app, dependencies) => {
       console.log('[Server] Creating command');
 
       createCommand(commandName, config, directory, scope);
-      await refreshOpenCodeAfterConfigChange('command creation', {
-        commandName
-      });
-
-      res.json({
-        success: true,
-        requiresReload: true,
-        message: `Command ${commandName} created successfully. Reloading interface…`,
-        reloadDelayMs: clientReloadDelayMs,
-      });
+      res.json(configSaved());
     } catch (error) {
       console.error('Failed to create command');
       res.status(500).json({ error: error.message || 'Failed to create command' });
@@ -626,16 +648,10 @@ export const registerConfigEntityRoutes = (app, dependencies) => {
       console.log('[Server] Updating command');
 
       updateCommand(commandName, updates, directory);
-      await refreshOpenCodeAfterConfigChange('command update');
 
       console.log('[Server] Command updated successfully');
 
-      res.json({
-        success: true,
-        requiresReload: true,
-        message: `Command ${commandName} updated successfully. Reloading interface…`,
-        reloadDelayMs: clientReloadDelayMs,
-      });
+      res.json(configSaved());
     } catch (error) {
       console.error('[Server] Failed to update command');
       res.status(500).json({ error: error.message || 'Failed to update command' });
@@ -651,14 +667,7 @@ export const registerConfigEntityRoutes = (app, dependencies) => {
       }
 
       deleteCommand(commandName, directory);
-      await refreshOpenCodeAfterConfigChange('command deletion');
-
-      res.json({
-        success: true,
-        requiresReload: true,
-        message: `Command ${commandName} deleted successfully. Reloading interface…`,
-        reloadDelayMs: clientReloadDelayMs,
-      });
+      res.json(configSaved());
     } catch (error) {
       console.error('Failed to delete command');
       res.status(500).json({ error: error.message || 'Failed to delete command' });