@vantran-se/openchamber-web 2.0.3 → 2.0.5

package/server/lib/opencode/lifecycle.js

@@ -1,4 +1,4 @@
-import { readOpenCodeInfo, isSupportedOpenCodeVersion, requireOpenCodeV2, UnsupportedOpenCodeVersionError } from './compatibility.js';
+import { readOpenCodeInfo, readExternalOpenCodeVersion, isSupportedOpenCodeVersion, requireOpenCodeV2, UnsupportedOpenCodeVersionError } from './compatibility.js';
 import { spawn, spawnSync } from 'node:child_process';
 import net from 'node:net';
 import { stripAppImageArgv0Leak } from '../inherited-env.js';
@@ -55,6 +55,132 @@ const WARMUP_REQUEST_TIMEOUT_MS = 30000;
 const MANAGED_STDERR_TAIL_MAX_BYTES = 32 * 1024;
 const HEALTH_FAILURE_DETAIL_MAX_LENGTH = 256;
 
+export const resolveOpenCodeConnectionKind = ({ runtime, configuredHost, lifecycleMode }) => {
+  if (configuredHost) return 'explicit-external';
+  if (lifecycleMode === 'managed' || runtime === 'desktop') return 'managed-owned';
+  return 'shared-local';
+};
+
+export const createOpenCodeServerComposition = ({
+  runtime,
+  configuredHost,
+  lifecycleMode,
+  createSharedRuntime,
+  createManagedPluginRuntime = () => null,
+  getManagedBaseUrl = () => null,
+  getManagedAuthHeaders = () => ({}),
+}) => {
+  const kind = resolveOpenCodeConnectionKind({ runtime, configuredHost, lifecycleMode });
+  if (kind === 'shared-local' && !createSharedRuntime) {
+    throw new Error('Shared OpenCode composition requires a shared runtime factory');
+  }
+  const sharedRuntime = kind === 'shared-local' ? createSharedRuntime() : null;
+  const managedPluginRuntime = kind === 'managed-owned' ? createManagedPluginRuntime() : null;
+  const connection = createOpenCodeConnectionAdapter({
+    kind,
+    sharedRuntime,
+    getManagedBaseUrl,
+    getManagedAuthHeaders,
+  });
+  return { kind, sharedRuntime, managedPluginRuntime, connection };
+};
+
+export const createOpenCodeRecoveryCallbacks = ({
+  resetOpenCodeRuntimeProviders,
+  rebindUpstream,
+  interruptBusySessionsAfterRestart,
+  broadcastUiNotification,
+}) => ({
+  onManagedRestarted() {
+    resetOpenCodeRuntimeProviders();
+    try {
+      rebindUpstream();
+    } catch (error) {
+      console.warn('Failed to rebind message stream after OpenCode restart:', error?.message ?? error);
+    }
+    try {
+      const { sessionIds } = interruptBusySessionsAfterRestart();
+      if (sessionIds.length === 0) return;
+      const multiple = sessionIds.length > 1;
+      broadcastUiNotification({
+        title: multiple ? 'Chats interrupted' : 'Chat interrupted',
+        body: multiple
+          ? 'OpenCode restarted during running responses. Send a message in each chat to continue.'
+          : 'OpenCode restarted during a running response. Send a message to continue.',
+        tag: 'opencode-restart-interrupted',
+        kind: 'opencode-restart-interrupted',
+        sessionId: sessionIds[0],
+      });
+    } catch (error) {
+      console.warn('Failed to reconcile sessions after OpenCode restart:', error?.message ?? error);
+    }
+  },
+  onSharedRecovered() {
+    resetOpenCodeRuntimeProviders();
+    rebindUpstream();
+  },
+});
+
+export const createOpenCodeLifecycleControls = ({
+  getKind,
+  restartLifecycle,
+  triggerLifecycleHealthCheck,
+  recoverShared,
+  onSharedRecovered,
+}) => {
+  let sharedRecoveryPromise = null;
+  const recover = () => {
+    if (!recoverShared || !onSharedRecovered) {
+      return Promise.reject(new Error('Shared OpenCode recovery is not configured'));
+    }
+    if (!sharedRecoveryPromise) {
+      sharedRecoveryPromise = Promise.resolve()
+        .then(() => recoverShared())
+        .then(() => onSharedRecovered())
+        .finally(() => {
+          sharedRecoveryPromise = null;
+        });
+    }
+    return sharedRecoveryPromise;
+  };
+
+  return {
+    restart: (...args) => (
+      getKind() === 'shared-local' ? recover() : restartLifecycle(...args)
+    ),
+    triggerHealthCheck: (...args) => {
+      if (getKind() !== 'shared-local') {
+        return triggerLifecycleHealthCheck(...args);
+      }
+      return recover().catch((error) => {
+        console.warn('Failed to recover shared OpenCode service:', error?.message ?? error);
+      });
+    },
+  };
+};
+
+export const createOpenCodeConnectionAdapter = ({
+  kind,
+  sharedRuntime = null,
+  getManagedBaseUrl = () => null,
+  getManagedAuthHeaders = () => ({}),
+}) => {
+  if (kind === 'shared-local' && !sharedRuntime) {
+    throw new Error('Shared OpenCode connection requires a shared service runtime');
+  }
+
+  return {
+    getOpenCodeConnectionKind: () => kind,
+    getOpenCodeBaseUrl: () => (
+      kind === 'shared-local' ? sharedRuntime.getBaseUrl() : getManagedBaseUrl()
+    ),
+    getOpenCodeAuthHeaders: () => (
+      kind === 'shared-local' ? sharedRuntime.getHeaders() : getManagedAuthHeaders()
+    ),
+    ownsOpenCodeProcess: () => kind === 'managed-owned',
+  };
+};
+
 const getBoundedTextTail = (value, maxBytes) => {
   const buffer = Buffer.from(String(value ?? ''));
   if (buffer.byteLength <= maxBytes) return buffer.toString();
@@ -677,6 +803,16 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
     }
   };
 
+  // The version of an explicitly configured server that answered but is not a
+  // supported OpenCode (v1, or 2.x below the minimum); null for anything else,
+  // including a server that is down.
+  const readUnsupportedExternalOpenCodeVersion = async (port, origin) => {
+    if (!port || port <= 0) return null;
+    const version = await readExternalOpenCodeVersion(origin ?? `http://127.0.0.1:${port}`, getOpenCodeAuthHeaders())
+      .catch(() => null);
+    return version && !isSupportedOpenCodeVersion(version) ? version : null;
+  };
+
   const waitForOpenCodePort = async (timeoutMs = 15000) => {
     if (state.openCodePort !== null) {
       return state.openCodePort;
@@ -991,7 +1127,7 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
         }
 
         const info = await readOpenCodeInfo(response);
-        if (!info) throw new Error('OpenCode did not return valid version information.');
+        if (!info) throw new Error('The server did not identify itself as OpenCode 2.x. OpenChamber requires OpenCode 2.x; if the server runs an older OpenCode, upgrade it.');
         if (!isSupportedOpenCodeVersion(info.version)) throw new UnsupportedOpenCodeVersionError(info.version);
         state.isOpenCodeReady = true;
         state.lastOpenCodeError = null;
@@ -1090,6 +1226,7 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
   const bootstrapOpenCodeAtStartup = async () => {
     const bootstrapStartedAt = performance.now();
     let bootstrapError = null;
+    let unsupportedExternalVersion = null;
     recordStartupPerformance('opencode.bootstrap.start');
     try {
       // Before doing anything, reap any OpenCode process WE spawned in a prior
@@ -1130,6 +1267,20 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
         state.lastOpenCodeError = null;
         state.openCodeNotReadySince = 0;
         syncToHmrState();
+      } else if (env.ENV_EFFECTIVE_PORT && (unsupportedExternalVersion = await readUnsupportedExternalOpenCodeVersion(
+        env.ENV_EFFECTIVE_PORT,
+        env.ENV_CONFIGURED_OPENCODE_HOST?.origin,
+      ))) {
+        // The configured server is an OpenCode this OpenChamber cannot use.
+        // Attach to it anyway, not ready, so the compatibility check reports
+        // its version instead of a managed instance silently replacing it.
+        const label = env.ENV_CONFIGURED_OPENCODE_HOST ? env.ENV_CONFIGURED_OPENCODE_HOST.origin : `http://localhost:${env.ENV_EFFECTIVE_PORT}`;
+        console.warn(`OpenCode ${unsupportedExternalVersion} at ${label} is not supported by this OpenChamber`);
+        state.openCodeBaseUrl = env.ENV_CONFIGURED_OPENCODE_HOST?.origin ?? null;
+        setOpenCodePort(env.ENV_EFFECTIVE_PORT);
+        state.isExternalOpenCode = true;
+        syncToHmrState();
+        throw new UnsupportedOpenCodeVersionError(unsupportedExternalVersion);
       } else {
         // We never auto-attach to an arbitrary pre-existing OpenCode instance.
         // Attaching to an external server requires explicit opt-in via env
@@ -1156,6 +1307,9 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
         await waitForOpenCodeReady();
       } catch (error) {
         bootstrapError = error;
+        // Skip-start mode assumed readiness up front; a server that never
+        // proved itself must not keep reporting ready to startup diagnostics.
+        state.isOpenCodeReady = false;
         console.error(`OpenCode readiness check failed: ${error.message}`);
       }
     } catch (error) {

package/server/lib/opencode/lifecycle.test.js

@@ -18,7 +18,14 @@ vi.mock('./startup-performance.js', () => ({
   recordStartupPerformance: recordStartupPerformanceMock,
 }));
 
-const { createOpenCodeLifecycleRuntime } = await import('./lifecycle.js');
+const {
+  createOpenCodeConnectionAdapter,
+  createOpenCodeLifecycleControls,
+  createOpenCodeLifecycleRuntime,
+  createOpenCodeRecoveryCallbacks,
+  createOpenCodeServerComposition,
+  resolveOpenCodeConnectionKind,
+} = await import('./lifecycle.js');
 
 const originalOpencodeBinary = process.env.OPENCODE_BINARY;
 const originalPath = process.env.PATH;
@@ -128,6 +135,226 @@ const createRuntime = (overrides = {}, stateOverrides = {}, envOverrides = {}) =
   return runtime;
 };
 
+describe('OpenCode connection composition', () => {
+  it('selects shared-local for Web without an explicit host', () => {
+    expect(resolveOpenCodeConnectionKind({ runtime: 'web', configuredHost: null })).toBe('shared-local');
+  });
+
+  it('selects explicit-external when a host is configured', () => {
+    expect(resolveOpenCodeConnectionKind({
+      runtime: 'web',
+      configuredHost: { origin: 'https://opencode.example.com', port: 443 },
+    })).toBe('explicit-external');
+  });
+
+  it('keeps Desktop on the managed-owned lifecycle', () => {
+    expect(resolveOpenCodeConnectionKind({ runtime: 'desktop', configuredHost: null })).toBe('managed-owned');
+  });
+
+  it('gives an explicit host priority over the Desktop managed lifecycle', () => {
+    expect(resolveOpenCodeConnectionKind({
+      runtime: 'desktop',
+      configuredHost: { origin: 'https://opencode.example.com', port: 443 },
+    })).toBe('explicit-external');
+  });
+
+  it('keeps an embedded managed override on the managed-owned lifecycle', () => {
+    expect(resolveOpenCodeConnectionKind({
+      runtime: 'web',
+      configuredHost: null,
+      lifecycleMode: 'managed',
+    })).toBe('managed-owned');
+  });
+
+  it('requires a shared runtime factory for shared-local composition', () => {
+    expect(() => createOpenCodeServerComposition({
+      runtime: 'web',
+      configuredHost: null,
+    })).toThrow('Shared OpenCode composition requires a shared runtime factory');
+  });
+
+  it('creates shared and managed-only runtimes only for their owning connection kind', () => {
+    const sharedRuntime = { getBaseUrl: () => null, getHeaders: () => ({}) };
+    const managedPluginRuntime = { buildManagedChildEnv: () => ({}) };
+    const createSharedRuntime = vi.fn(() => sharedRuntime);
+    const createManagedPluginRuntime = vi.fn(() => managedPluginRuntime);
+
+    const shared = createOpenCodeServerComposition({
+      runtime: 'web',
+      configuredHost: null,
+      createSharedRuntime,
+      createManagedPluginRuntime,
+    });
+    const external = createOpenCodeServerComposition({
+      runtime: 'web',
+      configuredHost: { origin: 'https://opencode.example.com', port: 443 },
+      createSharedRuntime,
+      createManagedPluginRuntime,
+    });
+    const desktop = createOpenCodeServerComposition({
+      runtime: 'desktop',
+      configuredHost: null,
+      createSharedRuntime,
+      createManagedPluginRuntime,
+    });
+
+    expect(shared.sharedRuntime).toBe(sharedRuntime);
+    expect(shared.managedPluginRuntime).toBeNull();
+    expect(external.sharedRuntime).toBeNull();
+    expect(external.managedPluginRuntime).toBeNull();
+    expect(desktop.sharedRuntime).toBeNull();
+    expect(desktop.managedPluginRuntime).toBe(managedPluginRuntime);
+    expect(createSharedRuntime).toHaveBeenCalledTimes(1);
+    expect(createManagedPluginRuntime).toHaveBeenCalledTimes(1);
+  });
+
+  it('recovers the shared service through the production callback without interrupting sessions', async () => {
+    const restartManaged = vi.fn(async () => {});
+    const triggerManagedHealthCheck = vi.fn(async () => {});
+    const recoverShared = vi.fn(async () => {});
+    const resetOpenCodeRuntimeProviders = vi.fn();
+    const rebindUpstream = vi.fn();
+    const interruptBusySessionsAfterRestart = vi.fn(() => ({ sessionIds: [] }));
+    const broadcastUiNotification = vi.fn();
+    const callbacks = createOpenCodeRecoveryCallbacks({
+      resetOpenCodeRuntimeProviders,
+      rebindUpstream,
+      interruptBusySessionsAfterRestart,
+      broadcastUiNotification,
+    });
+    const shared = createOpenCodeLifecycleControls({
+      getKind: () => 'shared-local',
+      restartLifecycle: restartManaged,
+      triggerLifecycleHealthCheck: triggerManagedHealthCheck,
+      recoverShared,
+      onSharedRecovered: callbacks.onSharedRecovered,
+    });
+
+    await shared.restart('manual');
+
+    expect(recoverShared).toHaveBeenCalledOnce();
+    expect(resetOpenCodeRuntimeProviders).toHaveBeenCalledOnce();
+    expect(rebindUpstream).toHaveBeenCalledOnce();
+    expect(recoverShared.mock.invocationCallOrder[0]).toBeLessThan(rebindUpstream.mock.invocationCallOrder[0]);
+    expect(interruptBusySessionsAfterRestart).not.toHaveBeenCalled();
+    expect(broadcastUiNotification).not.toHaveBeenCalled();
+    expect(restartManaged).not.toHaveBeenCalled();
+    expect(triggerManagedHealthCheck).not.toHaveBeenCalled();
+  });
+
+  it('keeps managed restart interruption behavior in the production callback', () => {
+    const resetOpenCodeRuntimeProviders = vi.fn();
+    const rebindUpstream = vi.fn();
+    const interruptBusySessionsAfterRestart = vi.fn(() => ({ sessionIds: ['session-1'] }));
+    const broadcastUiNotification = vi.fn();
+    const callbacks = createOpenCodeRecoveryCallbacks({
+      resetOpenCodeRuntimeProviders,
+      rebindUpstream,
+      interruptBusySessionsAfterRestart,
+      broadcastUiNotification,
+    });
+
+    callbacks.onManagedRestarted();
+
+    expect(resetOpenCodeRuntimeProviders).toHaveBeenCalledOnce();
+    expect(rebindUpstream).toHaveBeenCalledOnce();
+    expect(interruptBusySessionsAfterRestart).toHaveBeenCalledOnce();
+    expect(broadcastUiNotification).toHaveBeenCalledWith(expect.objectContaining({
+      kind: 'opencode-restart-interrupted',
+      sessionId: 'session-1',
+    }));
+  });
+
+  it('shares concurrent shared recovery attempts', async () => {
+    let finishRecovery;
+    const recoverShared = vi.fn(() => new Promise((resolve) => {
+      finishRecovery = resolve;
+    }));
+    const onSharedRecovered = vi.fn(async () => {});
+    const shared = createOpenCodeLifecycleControls({
+      getKind: () => 'shared-local',
+      restartLifecycle: vi.fn(),
+      triggerLifecycleHealthCheck: vi.fn(),
+      recoverShared,
+      onSharedRecovered,
+    });
+
+    const first = shared.triggerHealthCheck();
+    const second = shared.triggerHealthCheck();
+    await vi.waitFor(() => expect(recoverShared).toHaveBeenCalledOnce());
+    finishRecovery();
+    await Promise.all([first, second]);
+
+    expect(recoverShared).toHaveBeenCalledOnce();
+    expect(onSharedRecovered).toHaveBeenCalledOnce();
+  });
+
+  it('contains shared health recovery failures and permits a later retry', async () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const recoverShared = vi.fn()
+      .mockRejectedValueOnce(new Error('service unavailable'))
+      .mockResolvedValueOnce(undefined);
+    const onSharedRecovered = vi.fn(async () => {});
+    const shared = createOpenCodeLifecycleControls({
+      getKind: () => 'shared-local',
+      restartLifecycle: vi.fn(),
+      triggerLifecycleHealthCheck: vi.fn(),
+      recoverShared,
+      onSharedRecovered,
+    });
+
+    await expect(shared.triggerHealthCheck()).resolves.toBeUndefined();
+    await expect(shared.restart()).resolves.toBeUndefined();
+
+    expect(recoverShared).toHaveBeenCalledTimes(2);
+    expect(onSharedRecovered).toHaveBeenCalledOnce();
+  });
+
+  it('preserves managed lifecycle controls', async () => {
+    const restartManaged = vi.fn(async () => {});
+    const triggerManagedHealthCheck = vi.fn(async () => {});
+    const managed = createOpenCodeLifecycleControls({
+      getKind: () => 'managed-owned',
+      restartLifecycle: restartManaged,
+      triggerLifecycleHealthCheck: triggerManagedHealthCheck,
+    });
+
+    await managed.restart('manual');
+    await managed.triggerHealthCheck();
+
+    expect(restartManaged).toHaveBeenCalledWith('manual');
+    expect(triggerManagedHealthCheck).toHaveBeenCalledTimes(1);
+  });
+
+  it('requires a shared runtime for shared-local composition', () => {
+    expect(() => createOpenCodeConnectionAdapter({ kind: 'shared-local' })).toThrow(
+      'Shared OpenCode connection requires a shared service runtime',
+    );
+  });
+
+  it('reads shared URL and auth from the shared runtime at call time without owning its process', () => {
+    let baseUrl = 'http://127.0.0.1:4096';
+    let headers = { authorization: 'Basic first' };
+    const adapter = createOpenCodeConnectionAdapter({
+      kind: 'shared-local',
+      sharedRuntime: {
+        getBaseUrl: () => baseUrl,
+        getHeaders: () => ({ ...headers }),
+      },
+    });
+
+    expect(adapter.getOpenCodeConnectionKind()).toBe('shared-local');
+    expect(adapter.getOpenCodeBaseUrl()).toBe('http://127.0.0.1:4096');
+    expect(adapter.getOpenCodeAuthHeaders()).toEqual({ authorization: 'Basic first' });
+    expect(adapter.ownsOpenCodeProcess()).toBe(false);
+
+    baseUrl = 'http://127.0.0.1:5096';
+    headers = { authorization: 'Basic replacement' };
+    expect(adapter.getOpenCodeBaseUrl()).toBe('http://127.0.0.1:5096');
+    expect(adapter.getOpenCodeAuthHeaders()).toEqual({ authorization: 'Basic replacement' });
+  });
+});
+
 describe('OpenCode lifecycle', () => {
   it('uses the resolved binary directly on startup and managed restart without an env override', async () => {
     delete process.env.OPENCODE_BINARY;
@@ -240,6 +467,33 @@ describe('OpenCode lifecycle', () => {
     expect(runtime.testState.openCodeBaseUrl).toBe('http://seamus:4095');
   });
 
+  it('attaches to an OPENCODE_HOST running OpenCode v1 instead of starting a managed server', async () => {
+    const requested = [];
+    globalThis.fetch = vi.fn(async (url) => {
+      const href = String(url);
+      requested.push(href);
+      if (href.endsWith('/global/health')) return Response.json({ healthy: true, version: '1.18.32' });
+      return new Response('<html>OpenCode</html>', { headers: { 'content-type': 'text/html' } });
+    });
+    const runtime = createRuntime({
+      reapManagedOrphanedProcesses: vi.fn(async () => ({ reaped: 0 })),
+    }, {}, {
+      ENV_CONFIGURED_OPENCODE_PORT: null,
+      ENV_CONFIGURED_OPENCODE_HOST: { origin: 'http://seamus:4095', port: 4095 },
+      ENV_EFFECTIVE_PORT: 4095,
+    });
+
+    await runtime.bootstrapOpenCodeAtStartup();
+
+    expect(spawnMock).not.toHaveBeenCalled();
+    expect(requested).toContain('http://seamus:4095/global/health');
+    expect(runtime.testState.isExternalOpenCode).toBe(true);
+    expect(runtime.testState.isOpenCodeReady).toBe(false);
+    expect(runtime.testState.openCodeBaseUrl).toBe('http://seamus:4095');
+    expect(runtime.testState.openCodePort).toBe(4095);
+    expect(runtime.testState.lastOpenCodeError).toContain('1.18.32');
+  });
+
   it('warms recently used directories after a successful bootstrap', async () => {
     const fetchMock = vi.fn(async () => ({
       ok: true,

package/server/lib/opencode/managed-config-file.js

@@ -2,6 +2,17 @@ import { appendManagedPlugin } from './managed-plugin-config.js';
 
 export const MANAGED_CONFIG_FILE_NAME = 'opencode.managed.json';
 
+/**
+ * Built-in OpenCode plugins OpenChamber switches off for its managed child.
+ *
+ * `opencode.browser` only works when OpenCode's own desktop app attaches a
+ * browser to the session; OpenChamber does not implement that protocol, so its
+ * tools always fail with `browser.disconnected` and agents conclude browsing is
+ * unavailable instead of using `openchamber_web`. A project config that lists
+ * `opencode.browser` still re-enables it, because that layer sits above ours.
+ */
+const DISABLED_BUILTIN_PLUGINS = ['-opencode.browser'];
+
 /**
  * The managed OpenCode config layer.
  *
@@ -12,7 +23,8 @@ export const MANAGED_CONFIG_FILE_NAME = 'opencode.managed.json';
  * process — where `OPENCODE_CONFIG_CONTENT` (an environment variable) could
  * only ever change across a restart.
  *
- * The file is OpenChamber-owned and holds nothing but `plugins`. It sits above
+ * The file is OpenChamber-owned and holds nothing but `plugins`: the built-in
+ * plugins OpenChamber disables, then its own plugin directories. It sits above
  * the user's global `opencode.json` and below their project config, so it never
  * shadows a project-level choice.
  *
@@ -46,7 +58,7 @@ export const createManagedConfigRuntime = ({
 
   const writeConfigFile = async (pluginDirectories) => {
     await fsPromises.mkdir(dataDir, { recursive: true });
-    const text = `${JSON.stringify({ plugins: pluginDirectories }, null, 2)}\n`;
+    const text = `${JSON.stringify({ plugins: [...DISABLED_BUILTIN_PLUGINS, ...pluginDirectories] }, null, 2)}\n`;
     // Temp + rename: OpenCode reacts to the write immediately, and a partial
     // read would make it drop every managed plugin until the next change.
     const tmp = `${filePath}.tmp-${process.pid}-${Date.now()}`;
@@ -69,10 +81,11 @@ export const createManagedConfigRuntime = ({
     const includeControl = settings?.agentControlToolEnabled !== false;
     const includeWeb = settings?.agentWebToolEnabled !== false;
     const includeMemory = isAgentMemoryAvailable() && settings?.agentMemoryToolEnabled === true;
+    const includeNotify = settings?.agentNotifyToolEnabled === true;
 
     const directories = [];
-    if (agentToolRuntime && (includeControl || includeWeb || includeMemory)) {
-      directories.push(await agentToolRuntime.materializePlugin({ includeControl, includeWeb, includeMemory }));
+    if (agentToolRuntime && (includeControl || includeWeb || includeMemory || includeNotify)) {
+      directories.push(await agentToolRuntime.materializePlugin({ includeControl, includeWeb, includeMemory, includeNotify }));
     }
     return directories;
   };
@@ -89,9 +102,8 @@ export const createManagedConfigRuntime = ({
       await writeConfigFile(directories);
       return { ...childEnv, OPENCODE_CONFIG: filePath };
     }
-    if (directories.length === 0) return childEnv;
     let content = env.OPENCODE_CONFIG_CONTENT;
-    for (const directory of directories) {
+    for (const directory of [...DISABLED_BUILTIN_PLUGINS, ...directories]) {
       content = appendManagedPlugin(content, directory, 'managed plugin');
     }
     return { ...childEnv, OPENCODE_CONFIG_CONTENT: content };

package/server/lib/opencode/managed-config-file.test.js

@@ -52,7 +52,7 @@ describe('managed OpenCode config file', () => {
     expect(childEnv.OPENCODE_CONFIG_CONTENT).toBeUndefined();
     expect(childEnv.OPENCHAMBER_AGENT_TOOL_TOKEN).toBe('token');
     expect(await readConfigFile()).toEqual({
-      plugins: [path.join(dataDir, 'agent-tool', 'openchamber-agent-tool')],
+      plugins: ['-opencode.browser', path.join(dataDir, 'agent-tool', 'openchamber-agent-tool')],
     });
   });
 
@@ -61,7 +61,7 @@ describe('managed OpenCode config file', () => {
 
     await runtime.buildManagedChildEnv();
 
-    for (const directory of (await readConfigFile()).plugins) {
+    for (const directory of (await readConfigFile()).plugins.filter((entry) => !entry.startsWith('-'))) {
       expect((await fs.stat(directory)).isDirectory()).toBe(true);
     }
   });
@@ -74,7 +74,7 @@ describe('managed OpenCode config file', () => {
     const childEnv = await runtime.buildManagedChildEnv();
 
     expect(agentToolRuntime.materializePlugin).not.toHaveBeenCalled();
-    expect(await readConfigFile()).toEqual({ plugins: [] });
+    expect(await readConfigFile()).toEqual({ plugins: ['-opencode.browser'] });
     // A tool switched on later reaches a process that can already call back.
     expect(childEnv.OPENCHAMBER_AGENT_TOOL_TOKEN).toBe('token');
   });
@@ -89,7 +89,7 @@ describe('managed OpenCode config file', () => {
     expect(await runtime.refreshManagedConfigFile()).toEqual({ updated: true });
 
     const { plugins } = await readConfigFile();
-    expect(plugins).toEqual([]);
+    expect(plugins).toEqual(['-opencode.browser']);
     expect(agentToolRuntime.createChildEnv).toHaveBeenCalledTimes(1);
   });
 
@@ -102,11 +102,27 @@ describe('managed OpenCode config file', () => {
     current.settings = { agentControlToolEnabled: false, agentWebToolEnabled: true };
     await runtime.refreshManagedConfigFile();
 
-    expect((await readConfigFile()).plugins).toHaveLength(1);
+    expect((await readConfigFile()).plugins).toHaveLength(2);
     expect(agentToolRuntime.materializePlugin).toHaveBeenCalledWith({
       includeControl: false,
       includeWeb: true,
       includeMemory: false,
+      includeNotify: false,
+    });
+  });
+
+  it('injects the notify tool only when it is switched on', async () => {
+    const { runtime, agentToolRuntime } = await createHarness({
+      settings: { agentControlToolEnabled: false, agentWebToolEnabled: false, agentNotifyToolEnabled: true },
+    });
+
+    await runtime.buildManagedChildEnv();
+
+    expect(agentToolRuntime.materializePlugin).toHaveBeenCalledWith({
+      includeControl: false,
+      includeWeb: false,
+      includeMemory: false,
+      includeNotify: true,
     });
   });
 
@@ -121,7 +137,7 @@ describe('managed OpenCode config file', () => {
     expect(childEnv.OPENCODE_CONFIG).toBeUndefined();
     expect(JSON.parse(childEnv.OPENCODE_CONFIG_CONTENT)).toEqual({
       model: 'test/model',
-      plugins: [path.join(dataDir, 'agent-tool', 'openchamber-agent-tool')],
+      plugins: ['-opencode.browser', path.join(dataDir, 'agent-tool', 'openchamber-agent-tool')],
     });
     await expect(fs.stat(path.join(dataDir, MANAGED_CONFIG_FILE_NAME))).rejects.toThrow();
     expect(await runtime.refreshManagedConfigFile()).toEqual({ updated: false, reason: 'external-config' });
@@ -147,6 +163,6 @@ describe('managed OpenCode config file', () => {
     await runtime.buildManagedChildEnv();
 
     expect(agentToolRuntime.materializePlugin).not.toHaveBeenCalled();
-    expect(await readConfigFile()).toEqual({ plugins: [] });
+    expect(await readConfigFile()).toEqual({ plugins: ['-opencode.browser'] });
   });
 });

package/server/lib/opencode/mcp.js

@@ -48,9 +48,14 @@ function ensureProjectMcpConfigPath(workingDirectory) {
   return path.join(configDir, 'opencode.json');
 }
 
-/** Same precedence as `getJsonEntrySource`: custom > project > user. */
+/** Same precedence as `getJsonEntrySource`: custom > project > user override > user. */
 function readMcpEntriesAcrossLayers(layers) {
-  return readLayeredMcpEntries([layers?.userConfig, layers?.projectConfig, layers?.customConfig]);
+  return readLayeredMcpEntries([
+    layers?.userConfig,
+    layers?.userOverrideConfig,
+    layers?.projectConfig,
+    layers?.customConfig,
+  ]);
 }
 
 function listMcpConfigs(workingDirectory) {