@vantran-se/openchamber-web 2.0.3 → 2.0.5

package/server/lib/opencode/provider-source-route.test.js

@@ -0,0 +1,59 @@
+import { describe, expect, it, vi } from 'vitest';
+import express from 'express';
+import request from 'supertest';
+import { registerOpenCodeRoutes } from './routes.js';
+
+const createApp = (getProviderSources) => {
+  const app = express();
+  app.use(express.json());
+  registerOpenCodeRoutes(app, {
+    resolveProjectDirectory: vi.fn(async () => ({ directory: '/projects/app' })),
+    getProviderSources,
+  });
+  return app;
+};
+
+describe('GET /api/provider/:providerId/source', () => {
+  it('returns the stored config entry next to the layer sources', async () => {
+    const stored = {
+      name: 'Stored',
+      package: 'aisdk:@ai-sdk/openai-compatible',
+      env: ['STORED_KEY'],
+      settings: { baseURL: 'https://stored.example.com/v1' },
+      models: { m: { modelID: 'm', name: 'M' } },
+    };
+    const getProviderSources = vi.fn(() => ({
+      sources: {
+        auth: { exists: false },
+        user: { exists: false, path: '/user.json' },
+        project: { exists: true, path: '/projects/app/opencode.json' },
+        custom: { exists: false, path: null },
+      },
+      config: stored,
+    }));
+
+    const response = await request(createApp(getProviderSources))
+      .get('/api/provider/stored-llm/source?directory=/projects/app')
+      .expect(200);
+
+    expect(getProviderSources).toHaveBeenCalledWith('stored-llm', '/projects/app');
+    expect(response.body.config).toEqual(stored);
+    expect(response.body.sources.project.exists).toBe(true);
+  });
+
+  it('returns null config when no layer defines the provider', async () => {
+    const response = await request(createApp(() => ({
+      sources: {
+        auth: { exists: false },
+        user: { exists: false, path: '/user.json' },
+        project: { exists: false, path: null },
+        custom: { exists: false, path: null },
+      },
+      config: null,
+    })))
+      .get('/api/provider/other/source')
+      .expect(200);
+
+    expect(response.body.config).toBeNull();
+  });
+});

package/server/lib/opencode/providers.js

@@ -11,6 +11,7 @@ import {
   deleteSectionEntry,
   toModelVariants,
   toProviderEntity,
+  readStoredProviderEntry,
   toProviderPackage,
   toNpmPackage,
 } from './config-v2.js';
@@ -43,6 +44,8 @@ function getProviderSources(providerId, workingDirectory) {
       project: { exists: providerExistsIn(projectConfig, providerId), path: paths.projectPath || null },
       custom: { exists: providerExistsIn(customConfig, providerId), path: paths.customPath },
     },
+    // Same precedence as the edit scope: custom > project > user.
+    config: readStoredProviderEntry([customConfig, projectConfig, userConfig], providerId),
   };
 }
 

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

@@ -436,6 +436,68 @@ describe('custom provider config persistence', () => {
     }
   });
 
+  test('getProviderSources returns the stored entry from a JSONC config, v2 shape, without the key', () => {
+    const configPath = path.join(projectDir, '.opencode', 'opencode.jsonc');
+    fs.mkdirSync(path.dirname(configPath), { recursive: true });
+    fs.writeFileSync(configPath, `{
+  // v1 spelling, still decoded by OpenCode 2
+  "provider": {
+    "stored-llm": {
+      "name": "Stored",
+      "npm": "@ai-sdk/openai-compatible",
+      "env": ["STORED_KEY"],
+      "options": { "baseURL": "https://stored.example.com/v1", "apiKey": "sk-secret", "timeout": 5 },
+      "models": { "m": { "name": "M", "variants": { "high": { "reasoningEffort": "high" } } } },
+    },
+  },
+}`, 'utf8');
+
+    const { config } = getProviderSources('stored-llm', projectDir);
+    expect(config).toEqual({
+      name: 'Stored',
+      package: 'aisdk:@ai-sdk/openai-compatible',
+      env: ['STORED_KEY'],
+      settings: { baseURL: 'https://stored.example.com/v1', timeout: 5 },
+      models: { m: { name: 'M', variants: [{ id: 'high', settings: { reasoningEffort: 'high' } }] } },
+    });
+    expect(getProviderSources('missing-llm', projectDir).config).toBeNull();
+  });
+
+  test('saving the stored entry back keeps env, settings and model fields it does not edit', () => {
+    const providerId = 'keep-llm';
+    const configPath = path.join(projectDir, '.opencode', 'opencode.json');
+    writeJson(configPath, {
+      providers: {
+        [providerId]: {
+          name: 'Keep',
+          package: 'aisdk:@ai-sdk/openai-compatible',
+          env: ['KEEP_KEY'],
+          settings: { baseURL: 'https://keep.example.com/v1', timeout: 5 },
+          body: { store: false },
+          models: { m: { modelID: 'm', name: 'M', limit: { context: 1000 } } },
+        },
+      },
+    });
+
+    const { config } = getProviderSources(providerId, projectDir);
+    upsertProviderConfig(providerId, {
+      name: config.name,
+      package: config.package,
+      env: config.env,
+      settings: { baseURL: config.settings.baseURL },
+      models: { m: { name: 'M renamed' } },
+    }, projectDir, 'project', { hasStoredAuth: true });
+
+    expect(readJson(configPath).providers[providerId]).toEqual({
+      name: 'Keep',
+      package: 'aisdk:@ai-sdk/openai-compatible',
+      env: ['KEEP_KEY'],
+      settings: { baseURL: 'https://keep.example.com/v1', timeout: 5 },
+      body: { store: false },
+      models: { m: { modelID: 'm', name: 'M renamed', limit: { context: 1000 } } },
+    });
+  });
+
   test('custom-scope edit updates custom layer without creating a user entry', () => {
     const providerId = `custom-scope-${Date.now()}`;
     const customPath = path.join(projectDir, 'custom-opencode.json');

package/server/lib/opencode/proxy.js

@@ -236,7 +236,7 @@ const SESSION_LIST_ALLOWED_FIELDS = [
   'fork',
 ];
 
-const sanitizeSessionListItem = (session) => {
+export const sanitizeSessionListItem = (session) => {
   if (!session || typeof session !== 'object' || Array.isArray(session)) {
     return session;
   }
@@ -307,6 +307,11 @@ export const registerOpenCodeProxy = (app, deps) => {
     // migrated.
     getArchivedSessions = null,
     getStoredSessionMetadata = null,
+    // Isolated spaces, when the feature's switch is on: the merged session list, and the hub
+    // whose space events the global SSE stream carries beside the host's. Both absent means
+    // the host's own answers go out exactly as before spaces.
+    mergeSpaceSessionList = null,
+    spaceEventHub = null,
   } = deps;
 
   /**
@@ -477,18 +482,15 @@ export const registerOpenCodeProxy = (app, deps) => {
   const resolveProxyTarget = () => {
     const runtimeState = getRuntime();
 
-    // `buildOpenCodeUrl` throws while the port is unknown, and the port is
-    // nulled on several runtime paths (health-check failure, failed restart),
-    // not just cold start. Checking first keeps a degraded OpenCode from
-    // making every proxied request pay for a thrown-and-caught exception.
-    if (runtimeState.openCodePort) {
-      try {
-        const resolved = normalizeProxyTarget(buildOpenCodeUrl('/', ''));
-        if (resolved) {
-          return resolved;
-        }
-      } catch {
+    // The shared-service endpoint can remain authoritative even when it has no
+    // explicit port (for example, HTTPS on its default port). Resolve it before
+    // consulting the legacy runtime snapshot.
+    try {
+      const resolved = normalizeProxyTarget(buildOpenCodeUrl('/', ''));
+      if (resolved) {
+        return resolved;
       }
+    } catch {
     }
 
     const externalBase = normalizeProxyTarget(runtimeState.openCodeBaseUrl);
@@ -550,6 +552,7 @@ export const registerOpenCodeProxy = (app, deps) => {
     let heartbeatTimer = null;
     let upstreamStallTimer = null;
     let didUpstreamStall = false;
+    let unsubscribeSpaceEvents = null;
     let writeQueue = Promise.resolve(true);
     const sseBoundary = createSseBoundaryTracker();
 
@@ -644,6 +647,26 @@ export const registerOpenCodeProxy = (app, deps) => {
         return writeQueue;
       };
 
+      // The events of isolated spaces ride the global stream too, one block each, written
+      // only between the upstream's own blocks so a block of the host's is never cut.
+      // A directory in the query or in the header scopes the stream to the host's one directory.
+      const isGlobalStream = !new URL(requestUrl, 'http://localhost').searchParams.get('directory') && !req.get('x-opencode-directory');
+      const pendingSpaceBlocks = [];
+      const flushSpaceBlocks = async () => {
+        while (pendingSpaceBlocks.length > 0 && sseBoundary.isAtBoundary() && !abortController.signal.aborted) {
+          const canContinue = await enqueueSseWrite(pendingSpaceBlocks.shift());
+          if (!canContinue) return false;
+        }
+        return true;
+      };
+      if (spaceEventHub && isGlobalStream) {
+        unsubscribeSpaceEvents = spaceEventHub.subscribeEvent((event) => {
+          if (event.spaceId === null) return;
+          pendingSpaceBlocks.push(`data: ${JSON.stringify(event.payload)}\n\n`);
+          void flushSpaceBlocks();
+        }, { spaces: true });
+      }
+
       scheduleHeartbeat();
       resetUpstreamStallTimer();
 
@@ -660,6 +683,9 @@ export const registerOpenCodeProxy = (app, deps) => {
           if (!canContinue) {
             break;
           }
+          if (!await flushSpaceBlocks()) {
+            break;
+          }
         }
       }
 
@@ -679,6 +705,7 @@ export const registerOpenCodeProxy = (app, deps) => {
         res.end();
       }
     } finally {
+      unsubscribeSpaceEvents?.();
       if (heartbeatTimer) {
         clearTimeout(heartbeatTimer);
         heartbeatTimer = null;
@@ -763,7 +790,13 @@ export const registerOpenCodeProxy = (app, deps) => {
       }
 
       res.setHeader('content-type', result.contentType);
-      res.json(await overlayOwnedStateOnList(sanitizeSessionListPayload(result.payload)));
+      const hostList = await overlayOwnedStateOnList(sanitizeSessionListPayload(result.payload));
+      // The first page of the global list carries every space's sessions after the host's; a
+      // later page, and a list scoped to one directory, are the host's alone.
+      const listQuery = new URL(upstreamPath, 'http://localhost').searchParams;
+      const scopedToDirectory = Boolean(listQuery.get('directory') || req.get('x-opencode-directory'));
+      const wantsSpaces = typeof mergeSpaceSessionList === 'function' && !listQuery.get('cursor') && !scopedToDirectory;
+      res.json(wantsSpaces ? await mergeSpaceSessionList(hostList) : hostList);
     } catch (error) {
       if (isAbortError(error)) {
         return;
@@ -973,10 +1006,14 @@ export const registerOpenCodeProxy = (app, deps) => {
     router: () => resolveProxyTarget(),
     on: {
       proxyReq: (proxyReq, req) => {
-        // Inject OpenCode auth headers
+        // The proxy middleware starts with browser headers. Never let an
+        // OpenChamber client credential reach OpenCode, even when the active
+        // OpenCode connection itself has no authorization header.
+        proxyReq.removeHeader('authorization');
         const authHeaders = getOpenCodeAuthHeaders();
-        if (authHeaders.Authorization) {
-          proxyReq.setHeader('Authorization', authHeaders.Authorization);
+        for (const [key, value] of Object.entries(authHeaders)) {
+          proxyReq.removeHeader(key);
+          proxyReq.setHeader(key, value);
         }
 
         if (req.headers?.['x-opencode-directory-encoding'] === 'uri') {

package/server/lib/opencode/routes-upgrade.test.js

@@ -86,7 +86,7 @@ describe('OpenCode upgrade routes', () => {
     expect(globalThis.fetch).not.toHaveBeenCalled();
   });
 
-  it.each(['external', 'unavailable', 'windows-arm64-workaround'])('rejects %s on the server', async (reason) => {
+  it.each(['external', 'unavailable'])('rejects %s on the server', async (reason) => {
     const { app, dependencies } = createApp({ getOpenCodeUpgradeCapability: () => ({ supported: false, reason }) });
     await request(app).post('/api/opencode/upgrade').send({}).expect(409);
     expect(dependencies.upgradeOpenCodeCli).not.toHaveBeenCalled();

package/server/lib/opencode/routes.js

@@ -10,7 +10,7 @@ import { getClaudeCliAuthStatus } from './claude-cli-auth.js';
 import { OPENCODE_CONFIG_DIR } from './shared.js';
 import { settingsSurfaceOf } from './settings-files.js';
 import { parseWebSearchSelection } from './config-v2.js';
-import { getWebSearchSource, setWebSearchSelection } from './websearch-config.js';
+import { getWebSearchSource, setWarmingEnabled, setWebSearchSelection } from './websearch-config.js';
 
 export const registerOpenCodeRoutes = (app, dependencies) => {
   const {
@@ -287,6 +287,7 @@ export const registerOpenCodeRoutes = (app, dependencies) => {
       return res.json({
         providerId,
         sources: sources.sources,
+        config: sources.config,
       });
     } catch (error) {
       console.error('Failed to get provider sources:', error);
@@ -379,6 +380,22 @@ export const registerOpenCodeRoutes = (app, dependencies) => {
     }
   });
 
+  // Session warming (`warming` in OpenCode config), written like the web
+  // search choice above. Settings reads the effective value from OpenCode.
+  app.put('/api/config/warming', (req, res) => {
+    const enabled = req.body?.enabled;
+    if (typeof enabled !== 'boolean') {
+      return res.status(400).json({ error: 'enabled must be a boolean' });
+    }
+    try {
+      const result = setWarmingEnabled(enabled);
+      return res.json({ success: true, changed: result.changed });
+    } catch (error) {
+      console.error('Failed to save session warming:', error);
+      return res.status(500).json({ error: error.message || 'Failed to save session warming' });
+    }
+  });
+
   app.delete('/api/provider/:providerId/auth', async (req, res) => {
     try {
       const { providerId } = req.params;
@@ -528,6 +545,24 @@ export const registerOpenCodeRoutes = (app, dependencies) => {
         return res.status(413).json({ error: `Content exceeds maximum size of ${MAX_BEHAVIOR_PROMPT_SIZE} bytes` });
       }
 
+      // `expectedContent` is what the editor loaded (null: no file). A file
+      // changed on disk since then is not overwritten with the stale copy.
+      if (req.body && Object.prototype.hasOwnProperty.call(req.body, 'expectedContent')) {
+        const expected = req.body.expectedContent;
+        let current = null;
+        try {
+          current = await fs.promises.readFile(AGENTS_MD_PATH, 'utf8');
+        } catch (error) {
+          if (error?.code !== 'ENOENT') throw error;
+        }
+        if (current !== expected) {
+          return res.status(409).json({
+            error: 'AGENTS.md changed on disk since it was loaded',
+            code: 'AGENTS_MD_CONFLICT',
+          });
+        }
+      }
+
       // Ensure parent directory exists
       const parentDir = path.dirname(AGENTS_MD_PATH);
       try {

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

@@ -31,6 +31,7 @@ export const createServerStartupRuntime = (dependencies) => {
     bindHost,
     startupTunnelRequest,
     onTunnelReady,
+    afterListening,
   }) => {
     let activePort = port;
 
@@ -45,6 +46,30 @@ export const createServerStartupRuntime = (dependencies) => {
         try {
           const addressInfo = server.address();
           activePort = typeof addressInfo === 'object' && addressInfo ? addressInfo.port : port;
+          try {
+            await afterListening?.({ activePort, bindHost });
+          } catch (error) {
+            if (typeof process.send === 'function' && process.connected) {
+              const startupError = {
+                type: 'openchamber:error',
+                code: error?.code || 'WEB_STARTUP_ERROR',
+                message: error instanceof Error ? error.message : String(error),
+              };
+              if (error?.url) startupError.url = error.url;
+              await new Promise((resolveStartupError) => {
+                try {
+                  process.send(startupError, () => resolveStartupError());
+                } catch {
+                  resolveStartupError();
+                }
+              });
+            }
+            await new Promise((resolveClose) => {
+              server.close(() => resolveClose());
+              server.closeAllConnections?.();
+            });
+            throw error;
+          }
 
           if (typeof process.send === 'function') {
             if (!process.connected) {

package/server/lib/opencode/server-startup-runtime.test.js

@@ -1,4 +1,4 @@
-import { describe, expect, test } from 'bun:test';
+import { describe, expect, test, mock } from 'bun:test';
 import { EventEmitter } from 'node:events';
 import { createServerStartupRuntime } from './server-startup-runtime.js';
 
@@ -7,6 +7,72 @@ import { createServerStartupRuntime } from './server-startup-runtime.js';
  * on a single uncaught exception turned every stray socket error into "the
  * instance is unreachable until restarted". Only a sustained storm shuts down.
  */
+describe('server startup readiness', () => {
+  test('reports daemon ready only after listener-dependent startup finishes', async () => {
+    const order = [];
+    const fakeProcess = {
+      connected: true,
+      send: mock((message, callback) => {
+        order.push(message.type);
+        callback();
+      }),
+    };
+    const server = new EventEmitter();
+    server.address = () => ({ port: 3901 });
+    server.listen = (_port, _host, callback) => callback();
+    const runtime = createServerStartupRuntime({
+      process: fakeProcess,
+      crypto: {},
+      server,
+      readSettingsFromDiskMigrated: async () => ({}),
+      tunnelAuthController: {},
+    });
+
+    await runtime.startListeningAndMaybeTunnel({
+      port: 0,
+      bindHost: '127.0.0.1',
+      afterListening: async () => order.push('prepared'),
+    });
+
+    expect(order).toEqual(['prepared', 'openchamber:ready']);
+  });
+
+  test('closes the listener and reports startup failure when listener-dependent startup fails', async () => {
+    const sent = [];
+    const fakeProcess = {
+      connected: true,
+      send: mock((message, callback) => {
+        sent.push(message);
+        callback();
+      }),
+    };
+    const server = new EventEmitter();
+    server.address = () => ({ port: 3901 });
+    server.listen = (_port, _host, callback) => callback();
+    server.close = mock((callback) => callback());
+    server.closeAllConnections = mock(() => {});
+    const runtime = createServerStartupRuntime({ process: fakeProcess, crypto: {}, server });
+    const startupError = Object.assign(new Error('shared service rejected'), {
+      code: 'OPENCODE_INCOMPATIBLE',
+    });
+
+    await expect(runtime.startListeningAndMaybeTunnel({
+      port: 0,
+      bindHost: '127.0.0.1',
+      afterListening: async () => { throw startupError; },
+    })).rejects.toBe(startupError);
+
+    expect(server.close).toHaveBeenCalledTimes(1);
+    expect(server.closeAllConnections).toHaveBeenCalledTimes(1);
+    expect(sent).toEqual([expect.objectContaining({
+      type: 'openchamber:error',
+      code: 'OPENCODE_INCOMPATIBLE',
+    })]);
+    expect(sent).not.toContainEqual(expect.objectContaining({ type: 'openchamber:ready' }));
+  });
+
+});
+
 describe('uncaught exception policy', () => {
   const setup = () => {
     const fakeProcess = new EventEmitter();

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

@@ -23,6 +23,8 @@ export const createServerUtilsRuntime = (dependencies) => {
     clearLastOpenCodeError,
     getLoginShellPath,
     getArchivedSessions = null,
+    getMergeSpaceSessionList = null,
+    getSpaceEventHub = null,
     getStoredSessionMetadata = null,
   } = dependencies;
 
@@ -221,6 +223,9 @@ export const createServerUtilsRuntime = (dependencies) => {
       getUiNotificationClients,
       getArchivedSessions,
       getStoredSessionMetadata,
+      // Read when the proxy is set up, after `main` decided whether the spaces host exists.
+      mergeSpaceSessionList: typeof getMergeSpaceSessionList === 'function' ? getMergeSpaceSessionList() : null,
+      spaceEventHub: typeof getSpaceEventHub === 'function' ? getSpaceEventHub() : null,
     });
   };
 

package/server/lib/opencode/settings-helpers.js

@@ -65,6 +65,7 @@ export const createSettingsHelpers = (dependencies) => {
   const SIDEBAR_PROJECT_DISPLAY_MODE_VALUES = new Set(['all', 'single']);
   const SIDEBAR_VIEW_MODE_VALUES = new Set(['projects', 'timeline']);
   const SIDEBAR_PROJECT_SORT_ORDER_VALUES = new Set(['manual', 'a-z', 'z-a', 'date-added', 'recent']);
+  const SIDEBAR_WORKTREE_SORT_ORDER_VALUES = new Set(['recent', 'manual', 'a-z']);
   const HIDDEN_MODELS_MAX = 1024;
   const RECENT_EFFORTS_MAX_KEYS = 128;
   const RECENT_EFFORTS_MAX_VARIANTS_PER_KEY = 5;
@@ -302,6 +303,9 @@ export const createSettingsHelpers = (dependencies) => {
     if (SIDEBAR_PROJECT_SORT_ORDER_VALUES.has(candidate.sidebarProjectSortOrder)) {
       result.sidebarProjectSortOrder = candidate.sidebarProjectSortOrder;
     }
+    if (SIDEBAR_WORKTREE_SORT_ORDER_VALUES.has(candidate.sidebarWorktreeSortOrder)) {
+      result.sidebarWorktreeSortOrder = candidate.sidebarWorktreeSortOrder;
+    }
     if (typeof candidate.sidebarShowRecentSection === 'boolean') {
       result.sidebarShowRecentSection = candidate.sidebarShowRecentSection;
     }
@@ -607,6 +611,12 @@ export const createSettingsHelpers = (dependencies) => {
     if (typeof candidate.agentMemoryToolEnabled === 'boolean') {
       result.agentMemoryToolEnabled = candidate.agentMemoryToolEnabled;
     }
+    if (typeof candidate.agentNotifyToolEnabled === 'boolean') {
+      result.agentNotifyToolEnabled = candidate.agentNotifyToolEnabled;
+    }
+    if (typeof candidate.isolatedSpacesEnabled === 'boolean') {
+      result.isolatedSpacesEnabled = candidate.isolatedSpacesEnabled;
+    }
     if (typeof candidate.openCodeUpdateToastDismissedVersion === 'string') {
       const version = candidate.openCodeUpdateToastDismissedVersion.trim();
       result.openCodeUpdateToastDismissedVersion = version.slice(0, VERSION_STRING_MAX_LENGTH);

package/server/lib/opencode/settings-helpers.test.js

@@ -764,13 +764,13 @@ describe('settings registry gate', () => {
     desktopLanAccessEnabled: true, desktopKeepAwakeEnabled: true, desktopMinimizeToTrayEnabled: true, desktopMacMenuBarEnabled: true,
     desktopUiPassword: 'secret', githubClientId: 'client', githubScopes: 'repo', skillCatalogs: [{ id: 'c', label: 'C', source: 'https://x' }],
     defaultGitIdentityId: 'global', permissionAutoAccept: { sessions: { s: true }, revision: 1 },
-    agentControlToolEnabled: true, agentWebToolEnabled: true, browserProvider: 'builtin', agentMemoryToolEnabled: true, openCodeUpdateToastDismissedVersion: '1.0.0',
+    agentControlToolEnabled: true, agentWebToolEnabled: true, browserProvider: 'builtin', agentMemoryToolEnabled: true, agentNotifyToolEnabled: true, isolatedSpacesEnabled: true, openCodeUpdateToastDismissedVersion: '1.0.0',
     autoDeleteEnabled: true, autoDeleteAfterDays: 30, sessionRetentionOnlyArchived: false, sessionRetentionAction: 'archive', terminalShell: 'zsh', terminalLoginShells: ['zsh'],
     openInAppId: 'vscode', dictationEnabled: true, sttProvider: 'local', sttServerUrl: 'http://localhost:8001/v1', sttModel: 'm', sttLocalModel: 'm', sttLanguage: 'en',
     tunnelProvider: 'cloudflare', tunnelMode: 'quick', tunnelBootstrapTtlMs: 600000, tunnelSessionTtlMs: 86400000, managedLocalTunnelConfigPath: '/tmp/x',
     managedRemoteTunnelHostname: 'x.example', managedRemoteTunnelToken: 'token', managedRemoteTunnelPresets: [{ id: 'a', name: 'A', hostname: 'a.example' }],
     managedRemoteTunnelSelectedPresetId: 'a', managedRemoteTunnelPresetTokens: { a: 'token' },
-    sidebarProjectDisplayMode: 'all', sidebarViewMode: 'timeline', sidebarProjectSortOrder: 'manual', sidebarShowRecentSection: true,
+    sidebarProjectDisplayMode: 'all', sidebarViewMode: 'timeline', sidebarProjectSortOrder: 'manual', sidebarWorktreeSortOrder: 'recent', sidebarShowRecentSection: true,
     workStatusPanelEnabled: true, workStatusHiddenSections: ['mcp'], workStatusHiddenSectionsExplicit: true, workStatusSectionOrder: ['mcp', 'session'],
     showReasoningTraces: true, streamingAutoFollowEnabled: true, collapsibleThinkingBlocks: true, showTextJustificationActivity: true,
     chatRenderMode: 'live', activityRenderMode: 'summary', mermaidRenderingMode: 'svg', userMessageRenderingMode: 'markdown', collapsibleUserMessages: true,

package/server/lib/opencode/settings-registry.json

@@ -123,9 +123,15 @@
     "browserProvider": {
       "scope": "instance"
     },
+    "agentNotifyToolEnabled": {
+      "scope": "instance"
+    },
     "agentMemoryToolEnabled": {
       "scope": "instance"
     },
+    "isolatedSpacesEnabled": {
+      "scope": "instance"
+    },
     "agentMemoryFeatureAvailable": {
       "scope": "instance",
       "computed": true
@@ -222,6 +228,9 @@
     "sidebarProjectSortOrder": {
       "scope": "profile"
     },
+    "sidebarWorktreeSortOrder": {
+      "scope": "profile"
+    },
     "sidebarShowRecentSection": {
       "scope": "profile"
     },
@@ -674,6 +683,14 @@
       "scope": "device",
       "local": true
     },
+    "diffFileListMode": {
+      "scope": "device",
+      "local": true
+    },
+    "diffFileTreeWidth": {
+      "scope": "device",
+      "local": true
+    },
     "linearIssueListStatus": {
       "scope": "device",
       "local": true

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

@@ -45,6 +45,7 @@ const MANAGED_PLUGIN_SETTINGS_KEYS = new Set([
   'agentControlToolEnabled',
   'agentWebToolEnabled',
   'agentMemoryToolEnabled',
+  'agentNotifyToolEnabled',
 ]);
 
 export const createSettingsRuntime = (deps) => {