@vantran-se/openchamber-web 2.0.4 → 2.0.5

package/server/lib/opencode/project-directory-runtime.test.js

@@ -42,6 +42,19 @@ describe('project directory runtime', () => {
       expect(result).toEqual({ ok: true, directory: '/real/path/to/project', requestedDirectory: '/symlink/path/to/project' });
     });
 
+    it('refuses a directory the host says no to, before it looks at the disk', async () => {
+      let statCalls = 0;
+      const runtime = createTestRuntime({
+        fsPromises: { stat: async () => { statCalls += 1; return { isDirectory: () => true }; }, realpath: async (p) => p },
+        refuseDirectory: (candidate) => (candidate.startsWith('/spaces/') ? 'A directory under /spaces/ belongs to an isolated space' : null),
+      });
+
+      expect(await runtime.validateDirectoryPath('/spaces/a1b2c3d4e5f6/repo')).toEqual({ ok: false, error: 'A directory under /spaces/ belongs to an isolated space' });
+      expect(statCalls).toBe(0);
+      expect(await runtime.validateDirectoryPath('/home/user/project')).toMatchObject({ ok: true });
+      expect(statCalls).toBe(1);
+    });
+
     it('returns error when candidate is empty', async () => {
       const runtime = createTestRuntime();
       const result = await runtime.validateDirectoryPath('');

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;
 
   /**
@@ -547,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();
 
@@ -641,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();
 
@@ -657,6 +683,9 @@ export const registerOpenCodeProxy = (app, deps) => {
           if (!canContinue) {
             break;
           }
+          if (!await flushSpaceBlocks()) {
+            break;
+          }
         }
       }
 
@@ -676,6 +705,7 @@ export const registerOpenCodeProxy = (app, deps) => {
         res.end();
       }
     } finally {
+      unsubscribeSpaceEvents?.();
       if (heartbeatTimer) {
         clearTimeout(heartbeatTimer);
         heartbeatTimer = null;
@@ -760,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;

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-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) => {

package/server/lib/opencode/shared.js

@@ -280,11 +280,16 @@ function readConfigLayer(filePath) {
 function readConfigLayers(workingDirectory) {
   const { userPaths, projectPath, customPath } = getConfigPaths(workingDirectory);
   const userPath = getPrimaryUserConfigPath(userPaths);
+  // OpenCode loads every global config file in order, so an `opencode.jsonc`
+  // next to `opencode.json` overrides it. New entries still go to the primary
+  // file; entries found in the override are edited where they live.
+  const userOverridePath = userPaths.find((candidate) => candidate !== userPath && fs.existsSync(candidate)) ?? null;
   const userLayer = readConfigLayer(userPath);
+  const userOverrideLayer = readConfigLayer(userOverridePath);
   const projectLayer = readConfigLayer(projectPath);
   const customLayer = readConfigLayer(customPath);
   const mergedConfig = mergeConfigs(
-    mergeConfigs(userLayer.config, projectLayer.config),
+    mergeConfigs(mergeConfigs(userLayer.config, userOverrideLayer.config), projectLayer.config),
     customLayer.config,
   );
 
@@ -292,6 +297,9 @@ function readConfigLayers(workingDirectory) {
   if (userLayer.error) {
     layerErrors.push({ path: userPath, code: userLayer.error.code, message: userLayer.error.message });
   }
+  if (userOverrideLayer.error && userOverridePath) {
+    layerErrors.push({ path: userOverridePath, code: userOverrideLayer.error.code, message: userOverrideLayer.error.message });
+  }
   if (projectLayer.error && projectPath) {
     layerErrors.push({ path: projectPath, code: projectLayer.error.code, message: projectLayer.error.message });
   }
@@ -301,10 +309,11 @@ function readConfigLayers(workingDirectory) {
 
   return {
     userConfig: userLayer.config,
+    userOverrideConfig: userOverrideLayer.config,
     projectConfig: projectLayer.config,
     customConfig: customLayer.config,
     mergedConfig,
-    paths: { userPath, projectPath, customPath },
+    paths: { userPath, userOverridePath, projectPath, customPath },
     layerErrors,
   };
 }
@@ -407,6 +416,12 @@ function getJsonEntrySource(layers, sectionKind, entryName) {
     if (project) return project;
   }
 
+  if (paths.userOverridePath) {
+    throwIfLayerError(layers, paths.userOverridePath);
+    const userOverride = found(layers.userOverrideConfig, paths.userOverridePath);
+    if (userOverride) return userOverride;
+  }
+
   throwIfLayerError(layers, paths.userPath);
   const user = found(userConfig, paths.userPath);
   if (user) return user;
@@ -509,7 +524,20 @@ function walkSkillMdFiles(rootDir) {
   if (!rootDir || !fs.existsSync(rootDir)) return [];
 
   const results = [];
+  // Real paths of the directories on the current walk path. Links (symlinks and
+  // Windows junctions) are followed at any depth; a link back to one of its own
+  // ancestors is skipped instead of recursing forever. Two links to the same
+  // target elsewhere in the tree are both walked, as the top level always did.
+  const ancestors = new Set();
   const walk = (dir) => {
+    let realDir;
+    try {
+      realDir = fs.realpathSync(dir);
+    } catch {
+      return;
+    }
+    if (ancestors.has(realDir)) return;
+
     let entries = [];
     try {
       entries = fs.readdirSync(dir, { withFileTypes: true });
@@ -517,16 +545,33 @@ function walkSkillMdFiles(rootDir) {
       return;
     }
 
+    ancestors.add(realDir);
+
     for (const entry of entries) {
       const fullPath = path.join(dir, entry.name);
-      if (entry.isDirectory()) {
+      // Junctions report as links, not directories. A link whose target cannot be
+      // stat'ed is skipped, the way an unreadable directory is, instead of failing
+      // the whole scan.
+      let isDirectoryEntry = entry.isDirectory();
+      let isFileEntry = entry.isFile();
+      if (entry.isSymbolicLink()) {
+        try {
+          const target = fs.statSync(fullPath);
+          isDirectoryEntry = target.isDirectory();
+          isFileEntry = target.isFile();
+        } catch {
+          continue;
+        }
+      }
+      if (isDirectoryEntry) {
         walk(fullPath);
         continue;
       }
-      if (entry.isFile() && entry.name === 'SKILL.md') {
+      if (isFileEntry && entry.name === 'SKILL.md') {
         results.push(fullPath);
       }
     }
+    ancestors.delete(realDir);
   };
 
   walk(rootDir);

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

@@ -3,7 +3,7 @@ import fs from 'fs';
 import os from 'os';
 import path from 'path';
 
-import { parseMdFile, writeMdFile, readConfigFile, readConfigLayers, writeConfig } from './shared.js';
+import { parseMdFile, writeMdFile, readConfigFile, readConfigLayers, writeConfig, walkSkillMdFiles } from './shared.js';
 import { updateAgent } from './agents.js';
 import { updateMcpConfig } from './mcp.js';
 
@@ -388,3 +388,80 @@ describe('readConfigFile / writeConfig JSONC safety (issue #2923)', () => {
     }
   });
 });
+
+describe('walkSkillMdFiles', () => {
+  beforeEach(() => {
+    fs.rmSync(FIXTURE_DIR, { recursive: true, force: true });
+    fs.mkdirSync(FIXTURE_DIR, { recursive: true });
+  });
+
+  afterEach(() => {
+    fs.rmSync(FIXTURE_DIR, { recursive: true, force: true });
+  });
+
+  const writeSkill = (relativeDir) => writeFixture(path.join(relativeDir, 'SKILL.md'), STANDARD_MD);
+  // A junction needs no elevation on Windows, which is what Skills Manager deploys;
+  // the type argument is ignored on POSIX.
+  const linkDirectory = (target, relativeLink) =>
+    fs.symlinkSync(target, path.join(FIXTURE_DIR, relativeLink), process.platform === 'win32' ? 'junction' : 'dir');
+  const foundRelative = () =>
+    walkSkillMdFiles(FIXTURE_DIR)
+      .map((found) => path.relative(FIXTURE_DIR, found).split(path.sep).join('/'))
+      .sort();
+
+  it('walks a skill deployed as a link inside the scanned root', () => {
+    writeSkill('real-skill');
+    fs.mkdirSync(path.join(FIXTURE_DIR, 'collection'), { recursive: true });
+    writeSkill(path.join('collection', 'nested-skill'));
+    linkDirectory(path.join(FIXTURE_DIR, 'real-skill'), 'linked-skill');
+    linkDirectory(path.join(FIXTURE_DIR, 'collection'), 'collection-link');
+
+    expect(foundRelative()).toEqual([
+      'collection-link/nested-skill/SKILL.md',
+      'collection/nested-skill/SKILL.md',
+      'linked-skill/SKILL.md',
+      'real-skill/SKILL.md',
+    ]);
+  });
+
+  it('ends on a link that points back into the scanned tree', () => {
+    fs.mkdirSync(path.join(FIXTURE_DIR, 'loopdir'), { recursive: true });
+    writeSkill('loopdir');
+    linkDirectory(FIXTURE_DIR, path.join('loopdir', 'back'));
+
+    expect(foundRelative()).toEqual(['loopdir/SKILL.md']);
+  });
+
+  it('skips a link whose target is gone and keeps the rest of the scan', () => {
+    writeSkill('real-skill');
+    fs.mkdirSync(path.join(FIXTURE_DIR, 'gone-skill'), { recursive: true });
+    linkDirectory(path.join(FIXTURE_DIR, 'gone-skill'), 'dangling-link');
+    fs.rmSync(path.join(FIXTURE_DIR, 'gone-skill'), { recursive: true, force: true });
+
+    expect(foundRelative()).toEqual(['real-skill/SKILL.md']);
+  });
+
+  it('follows a link nested below the top level of the scanned root', () => {
+    const outside = `${FIXTURE_DIR}-outside`;
+    fs.rmSync(outside, { recursive: true, force: true });
+    fs.mkdirSync(path.join(outside, 'deep-skill'), { recursive: true });
+    fs.writeFileSync(path.join(outside, 'deep-skill', 'SKILL.md'), STANDARD_MD);
+    fs.mkdirSync(path.join(FIXTURE_DIR, 'group'), { recursive: true });
+    try {
+      linkDirectory(path.join(outside, 'deep-skill'), path.join('group', 'linked'));
+      expect(foundRelative()).toEqual(['group/linked/SKILL.md']);
+    } finally {
+      fs.rmSync(outside, { recursive: true, force: true });
+    }
+  });
+
+  it('ends on a nested link loop between two directories', () => {
+    fs.mkdirSync(path.join(FIXTURE_DIR, 'a'), { recursive: true });
+    fs.mkdirSync(path.join(FIXTURE_DIR, 'b'), { recursive: true });
+    writeSkill('a');
+    linkDirectory(path.join(FIXTURE_DIR, 'b'), path.join('a', 'to-b'));
+    linkDirectory(path.join(FIXTURE_DIR, 'a'), path.join('b', 'to-a'));
+
+    expect(foundRelative()).toEqual(['a/SKILL.md', 'b/to-a/SKILL.md']);
+  });
+});

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

@@ -40,6 +40,7 @@ export const createGracefulShutdownRuntime = (dependencies) => {
     getDictationRuntime,
     getRelayService,
     getRelayReconcileTimer,
+    getSpacesHost = () => null,
   } = dependencies;
 
   let shutdownPromise = null;
@@ -78,6 +79,8 @@ export const createGracefulShutdownRuntime = (dependencies) => {
       () => clearInterval(getRelayReconcileTimer()),
       () => getGuestSurfaceRuntime()?.stop(),
       () => getRealtimeProxyRuntime()?.stop(),
+      // The isolated-spaces host, when the switch is on: its connections into spaces end here.
+      () => getSpacesHost()?.close(),
       () => getRelayService()?.stop(),
       () => getDictationRuntime()?.stop(),
       () => openCodeWatcherRuntime.stop(),