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

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

@@ -10,6 +10,7 @@ const originalPath = process.env.PATH;
 const originalLocalAppData = process.env.LOCALAPPDATA;
 const originalSystemRoot = process.env.SystemRoot;
 const originalBundledOpencodeCliDir = process.env.OPENCHAMBER_BUNDLED_OPENCODE_CLI_DIR;
+const originalOpenChamberDataDir = process.env.OPENCHAMBER_DATA_DIR;
 const originalResourcesPath = process.resourcesPath;
 const originalWslBinary = process.env.WSL_BINARY;
 const originalOpenChamberWslBinary = process.env.OPENCHAMBER_WSL_BINARY;
@@ -23,6 +24,16 @@ const createTempDir = (prefix) => {
   return dir;
 };
 
+const writeVersionBinary = (filePath, version) => {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  if (process.platform === 'win32') {
+    fs.writeFileSync(filePath, `@echo off\r\necho ${version}\r\n`);
+    return;
+  }
+  fs.writeFileSync(filePath, `#!${process.execPath}\nconsole.log(${JSON.stringify(version)});\n`);
+  fs.chmodSync(filePath, 0o755);
+};
+
 const setPlatform = (platform) => {
   Object.defineProperty(process, 'platform', {
     value: platform,
@@ -74,6 +85,12 @@ afterEach(() => {
     delete process.env.OPENCHAMBER_BUNDLED_OPENCODE_CLI_DIR;
   }
 
+  if (typeof originalOpenChamberDataDir === 'string') {
+    process.env.OPENCHAMBER_DATA_DIR = originalOpenChamberDataDir;
+  } else {
+    delete process.env.OPENCHAMBER_DATA_DIR;
+  }
+
   Object.defineProperty(process, 'resourcesPath', {
     configurable: true,
     value: originalResourcesPath,
@@ -112,6 +129,7 @@ const createRuntime = (settings, options = {}) => {
     readSettingsFromDiskMigrated: async () => settings,
     spawnSync: options.spawnSync,
     homedir: options.homedir,
+    ensurePinnedOpenCode2Cli: options.ensurePinnedOpenCode2Cli,
   });
 
   return { runtime, state };
@@ -119,11 +137,11 @@ const createRuntime = (settings, options = {}) => {
 
 describe('OpenCode env runtime', () => {
   it('throws a specific error for a missing configured OpenCode binary in strict mode', async () => {
-    const { runtime } = createRuntime({ opencodeBinary: '/missing/opencode' });
+    const { runtime } = createRuntime({ opencodeBinary: '/missing/opencode2' });
 
     await expect(runtime.applyOpencodeBinaryFromSettings({ strict: true })).rejects.toMatchObject({
       code: 'OPENCODE_BINARY_INVALID',
-      message: expect.stringContaining('Configured OpenCode binary not found: /missing/opencode'),
+      message: expect.stringContaining('Configured OpenCode binary not found: /missing/opencode2'),
     });
   });
 
@@ -139,7 +157,7 @@ describe('OpenCode env runtime', () => {
 
   it('applies a valid configured executable OpenCode binary', async () => {
     const dir = createTempDir('openchamber-opencode-bin-');
-    const binary = path.join(dir, 'opencode');
+    const binary = path.join(dir, 'opencode2');
     fs.writeFileSync(binary, '#!/bin/sh\nexit 0\n');
     fs.chmodSync(binary, 0o755);
     const { runtime, state } = createRuntime({ opencodeBinary: binary });
@@ -150,16 +168,71 @@ describe('OpenCode env runtime', () => {
     expect(state.resolvedOpencodeBinarySource).toBe('settings');
   });
 
+  it('skips a configured 1.x opencode version instead of aborting startup', async () => {
+    const dir = createTempDir('openchamber-opencode-1x-');
+    const binary = path.join(dir, 'opencode');
+    writeVersionBinary(binary, '1.18.4');
+    const { runtime } = createRuntime({ opencodeBinary: binary });
+
+    await expect(runtime.applyOpencodeBinaryFromSettings({ strict: true })).resolves.toBeNull();
+    expect(process.env.OPENCODE_BINARY).not.toBe(binary);
+  });
+
+  it('skips an explicit OPENCODE_BINARY that reports a 1.x version', () => {
+    const dir = createTempDir('openchamber-env-opencode-1x-');
+    const binary = path.join(dir, process.platform === 'win32' ? 'opencode.exe' : 'opencode');
+    writeVersionBinary(binary, '1.18.4');
+    process.env.OPENCODE_BINARY = binary;
+    const { runtime } = createRuntime({});
+
+    expect(runtime.resolveOpencodeCliPath()).not.toBe(binary);
+  });
+
+  it('discovers opencode from a home-directory install location', () => {
+    const home = createTempDir('openchamber-home-opencode-');
+    const binary = path.join(home, '.bun', 'bin', 'opencode');
+    writeVersionBinary(binary, '2.0.12');
+    process.env.PATH = createTempDir('openchamber-empty-path-home-');
+    delete process.env.OPENCODE_BINARY;
+    delete process.env.OPENCHAMBER_BUNDLED_OPENCODE_CLI_DIR;
+    const { runtime, state } = createRuntime({}, {
+      spawnSync: () => ({ status: 1, stdout: '', stderr: '' }),
+      homedir: () => home,
+    });
+
+    expect(runtime.resolveOpencodeCliPath()).toBe(binary);
+    expect(state.resolvedOpencodeBinarySource).toBe('fallback');
+  });
+
+  it('does not treat a PATH 1.x opencode binary as a resolved CLI', () => {
+    const pathDir = createTempDir('openchamber-path-opencode-1x-');
+    const pathBinary = path.join(pathDir, process.platform === 'win32' ? 'opencode.exe' : 'opencode');
+    fs.writeFileSync(pathBinary, '#!/bin/sh\nexit 0\n');
+    if (process.platform !== 'win32') {
+      fs.chmodSync(pathBinary, 0o755);
+    }
+    process.env.PATH = pathDir;
+    delete process.env.OPENCODE_BINARY;
+    delete process.env.OPENCHAMBER_BUNDLED_OPENCODE_CLI_DIR;
+    const emptyHome = createTempDir('openchamber-empty-home-1x-');
+    const { runtime, state } = createRuntime({}, {
+      spawnSync: () => ({ status: 1, stdout: '', stderr: '' }),
+      homedir: () => emptyHome,
+    });
+
+    expect(runtime.resolveOpencodeCliPath()).toBeNull();
+    expect(state.resolvedOpencodeBinarySource).toBeNull();
+  });
+
   it('prefers a user-installed OpenCode from PATH over the bundled CLI', () => {
     const bundledDir = createTempDir('openchamber-bundled-opencode-');
     const bundledBinary = path.join(bundledDir, process.platform === 'win32' ? 'opencode.exe' : 'opencode');
     const pathDir = createTempDir('openchamber-path-opencode-');
     const pathBinary = path.join(pathDir, process.platform === 'win32' ? 'opencode.exe' : 'opencode');
     fs.writeFileSync(bundledBinary, '#!/bin/sh\nexit 0\n');
-    fs.writeFileSync(pathBinary, '#!/bin/sh\nexit 0\n');
+    writeVersionBinary(pathBinary, '2.0.12');
     if (process.platform !== 'win32') {
       fs.chmodSync(bundledBinary, 0o755);
-      fs.chmodSync(pathBinary, 0o755);
     }
     process.env.OPENCHAMBER_BUNDLED_OPENCODE_CLI_DIR = bundledDir;
     process.env.PATH = pathDir;
@@ -174,12 +247,11 @@ describe('OpenCode env runtime', () => {
     const bundledDir = createTempDir('openchamber-bundled-opencode-');
     const bundledBinary = path.join(bundledDir, process.platform === 'win32' ? 'opencode.exe' : 'opencode');
     const explicitDir = createTempDir('openchamber-explicit-opencode-');
-    const explicitBinary = path.join(explicitDir, process.platform === 'win32' ? 'opencode.exe' : 'opencode');
+    const explicitBinary = path.join(explicitDir, process.platform === 'win32' ? 'opencode2.exe' : 'opencode2');
     fs.writeFileSync(bundledBinary, '#!/bin/sh\nexit 0\n');
-    fs.writeFileSync(explicitBinary, '#!/bin/sh\nexit 0\n');
+    writeVersionBinary(explicitBinary, '2.0.12');
     if (process.platform !== 'win32') {
       fs.chmodSync(bundledBinary, 0o755);
-      fs.chmodSync(explicitBinary, 0o755);
     }
     process.env.OPENCHAMBER_BUNDLED_OPENCODE_CLI_DIR = bundledDir;
     process.env.OPENCODE_BINARY = explicitBinary;
@@ -189,7 +261,7 @@ describe('OpenCode env runtime', () => {
     expect(state.resolvedOpencodeBinarySource).toBe('env');
   });
 
-  it('falls back to the bundled OpenCode CLI from Electron resourcesPath when nothing else is installed', () => {
+  it('does not use a bundled OpenCode CLI from Electron resourcesPath', () => {
     const resourcesPath = createTempDir('openchamber-resources-');
     const bundledDir = path.join(resourcesPath, 'opencode-cli');
     const bundledBinary = path.join(bundledDir, process.platform === 'win32' ? 'opencode.exe' : 'opencode');
@@ -203,18 +275,142 @@ describe('OpenCode env runtime', () => {
       value: resourcesPath,
     });
     process.env.PATH = createTempDir('openchamber-empty-path-');
-    delete process.env.OPENCHAMBER_BUNDLED_OPENCODE_CLI_DIR;
+    process.env.OPENCHAMBER_BUNDLED_OPENCODE_CLI_DIR = bundledDir;
     delete process.env.OPENCODE_BINARY;
-    // The bundled CLI is the LAST resort now — hide the machine's own installs
-    // from the home-directory fallbacks and shell discovery.
     const emptyHome = createTempDir('openchamber-empty-home-');
     const { runtime, state } = createRuntime({}, {
       spawnSync: () => ({ status: 1, stdout: '', stderr: '' }),
       homedir: () => emptyHome,
     });
 
-    expect(runtime.resolveOpencodeCliPath()).toBe(bundledBinary);
+    expect(runtime.resolveOpencodeCliPath()).toBeNull();
+    expect(state.resolvedOpencodeBinarySource).toBeNull();
+  });
+
+  it('discovers a previously installed pin from the OpenChamber data dir', () => {
+    const dataDir = createTempDir('openchamber-installed-cli-');
+    const installedDir = path.join(dataDir, 'opencode-cli', '2.0.12');
+    const installedBinary = path.join(installedDir, process.platform === 'win32' ? 'opencode.exe' : 'opencode');
+    fs.mkdirSync(installedDir, { recursive: true });
+    fs.writeFileSync(installedBinary, '#!/bin/sh\nexit 0\n');
+    if (process.platform !== 'win32') {
+      fs.chmodSync(installedBinary, 0o755);
+    }
+    process.env.OPENCHAMBER_DATA_DIR = dataDir;
+    process.env.PATH = createTempDir('openchamber-empty-path-installed-');
+    delete process.env.OPENCODE_BINARY;
+    delete process.env.OPENCHAMBER_BUNDLED_OPENCODE_CLI_DIR;
+    const emptyHome = createTempDir('openchamber-empty-home-installed-');
+    const { runtime, state } = createRuntime({}, {
+      spawnSync: () => ({ status: 1, stdout: '', stderr: '' }),
+      homedir: () => emptyHome,
+    });
+
+    expect(runtime.resolveOpencodeCliPath()).toBe(installedBinary);
+    expect(state.resolvedOpencodeBinarySource).toBe('installed');
+  });
+
+  it('installs the pinned CLI when discovery finds nothing', async () => {
+    const installed = path.join(createTempDir('openchamber-ensure-install-'), process.platform === 'win32' ? 'opencode2.exe' : 'opencode2');
+    fs.writeFileSync(installed, '#!/bin/sh\nexit 0\n');
+    if (process.platform !== 'win32') {
+      fs.chmodSync(installed, 0o755);
+    }
+    process.env.PATH = createTempDir('openchamber-empty-path-ensure-');
+    delete process.env.OPENCODE_BINARY;
+    delete process.env.OPENCHAMBER_BUNDLED_OPENCODE_CLI_DIR;
+    const emptyHome = createTempDir('openchamber-empty-home-ensure-');
+    const { runtime, state } = createRuntime({}, {
+      spawnSync: () => ({ status: 1, stdout: '', stderr: '' }),
+      homedir: () => emptyHome,
+      ensurePinnedOpenCode2Cli: async () => ({
+        path: installed,
+        version: '2.0.12',
+        source: 'installed',
+        installed: true,
+      }),
+    });
+
+    await expect(runtime.ensurePinnedOpenCode2CliEnv()).resolves.toBe(installed);
+    expect(state.resolvedOpencodeBinary).toBe(installed);
+    expect(state.resolvedOpencodeBinarySource).toBe('installed');
+    expect(process.env.OPENCODE_BINARY).toBe(installed);
+  });
+
+  it('falls back to a bundled 2.x CLI only after pin install fails', async () => {
+    const bundledDir = createTempDir('openchamber-bundled-fallback-');
+    const bundledName = process.platform === 'win32' ? 'opencode.exe' : 'opencode';
+    const bundledBinary = path.join(bundledDir, bundledName);
+    writeVersionBinary(bundledBinary, '2.0.12');
+    process.env.OPENCHAMBER_BUNDLED_OPENCODE_CLI_DIR = bundledDir;
+    process.env.PATH = createTempDir('openchamber-empty-path-bundled-fallback-');
+    process.env.OPENCHAMBER_DATA_DIR = createTempDir('openchamber-empty-data-bundled-fallback-');
+    delete process.env.OPENCODE_BINARY;
+    const emptyHome = createTempDir('openchamber-empty-home-bundled-fallback-');
+    const missingError = Object.assign(new Error('OpenCode CLI missing'), { code: 'OPENCODE_CLI_MISSING' });
+    const { runtime, state } = createRuntime({}, {
+      spawnSync: () => ({ status: 1, stdout: '', stderr: '' }),
+      homedir: () => emptyHome,
+      ensurePinnedOpenCode2Cli: async () => {
+        throw missingError;
+      },
+    });
+
+    await expect(runtime.ensurePinnedOpenCode2CliEnv()).resolves.toBe(bundledBinary);
+    expect(state.resolvedOpencodeBinary).toBe(bundledBinary);
+    expect(state.resolvedOpencodeBinarySource).toBe('bundled');
+    expect(process.env.OPENCODE_BINARY).toBe(bundledBinary);
+  });
+
+  it('falls back to bundled opencode name when pin install fails', async () => {
+    const bundledDir = createTempDir('openchamber-bundled-opencode-name-');
+    const bundledName = process.platform === 'win32' ? 'opencode.exe' : 'opencode';
+    const bundledBinary = path.join(bundledDir, bundledName);
+    writeVersionBinary(bundledBinary, '2.0.12');
+    process.env.OPENCHAMBER_BUNDLED_OPENCODE_CLI_DIR = bundledDir;
+    process.env.PATH = createTempDir('openchamber-empty-path-bundled-opencode-');
+    process.env.OPENCHAMBER_DATA_DIR = createTempDir('openchamber-empty-data-bundled-opencode-');
+    delete process.env.OPENCODE_BINARY;
+    const emptyHome = createTempDir('openchamber-empty-home-bundled-opencode-');
+    const missingError = Object.assign(new Error('OpenCode CLI missing'), { code: 'OPENCODE_CLI_MISSING' });
+    const { runtime, state } = createRuntime({}, {
+      spawnSync: () => ({ status: 1, stdout: '', stderr: '' }),
+      homedir: () => emptyHome,
+      ensurePinnedOpenCode2Cli: async () => {
+        throw missingError;
+      },
+    });
+
+    await expect(runtime.ensurePinnedOpenCode2CliEnv()).resolves.toBe(bundledBinary);
     expect(state.resolvedOpencodeBinarySource).toBe('bundled');
+    expect(process.env.OPENCODE_BINARY).toBe(bundledBinary);
+  });
+
+  it('does not adopt a bundled 1.x CLI after pin install fails', async () => {
+    const bundledDir = createTempDir('openchamber-bundled-1x-');
+    const bundledName = process.platform === 'win32' ? 'opencode.exe' : 'opencode';
+    const bundledBinary = path.join(bundledDir, bundledName);
+    writeVersionBinary(bundledBinary, '1.18.4');
+    process.env.OPENCHAMBER_BUNDLED_OPENCODE_CLI_DIR = bundledDir;
+    process.env.PATH = createTempDir('openchamber-empty-path-bundled-1x-');
+    process.env.OPENCHAMBER_DATA_DIR = createTempDir('openchamber-empty-data-bundled-1x-');
+    delete process.env.OPENCODE_BINARY;
+    const emptyHome = createTempDir('openchamber-empty-home-bundled-1x-');
+    const missingError = Object.assign(new Error('OpenCode CLI missing'), { code: 'OPENCODE_CLI_MISSING' });
+    const { runtime, state } = createRuntime({}, {
+      spawnSync: () => ({ status: 1, stdout: '', stderr: '' }),
+      homedir: () => emptyHome,
+      ensurePinnedOpenCode2Cli: async () => {
+        throw missingError;
+      },
+    });
+
+    await expect(runtime.ensurePinnedOpenCode2CliEnv()).rejects.toMatchObject({
+      code: 'OPENCODE_CLI_MISSING',
+    });
+    expect(state.resolvedOpencodeBinary).toBeNull();
+    expect(state.resolvedOpencodeBinarySource).toBeNull();
+    expect(process.env.OPENCODE_BINARY).toBeUndefined();
   });
 
   itIf(process.platform === 'darwin')('rejects known macOS OpenCode app bundle executable paths', async () => {
@@ -265,7 +461,8 @@ describe('OpenCode env runtime', () => {
     const cliBinary = path.join(createTempDir('openchamber-cli-'), 'opencode.exe');
     fs.mkdirSync(path.dirname(desktopBinary), { recursive: true });
     fs.writeFileSync(desktopBinary, '');
-    fs.writeFileSync(cliBinary, '');
+    fs.writeFileSync(cliBinary, `#!${process.execPath}\nconsole.log('2.0.12');\n`);
+    fs.chmodSync(cliBinary, 0o755);
     process.env.LOCALAPPDATA = localAppData;
     process.env.PATH = createTempDir('openchamber-empty-path-');
     process.env.SystemRoot = createTempDir('openchamber-empty-systemroot-');

package/server/lib/opencode/feature-routes-runtime.js

@@ -2,6 +2,7 @@ import { registerFsRoutes } from '../fs/routes.js';
 import { registerQuotaRoutes } from '../quota/routes.js';
 import { registerSmallModelRoutes } from '../small-model/routes.js';
 import { registerSessionGoalRoutes } from '../session-goal/routes.js';
+import { registerSessionMetadataRoutes } from '../session-metadata/routes.js';
 import { registerGitHubRoutes } from '../github/routes.js';
 import { registerGitRoutes } from '../git/routes.js';
 import { registerMagicPromptRoutes } from '../magic-prompts/routes.js';
@@ -18,13 +19,16 @@ import { registerSessionTurnPageRoutes } from '../session-turn-pages/routes.js';
 import { registerAssistantRoutes } from '../assistants/routes.js';
 import { registerLlmRoutes } from '../llm/routes.js';
 import { registerMessageQueueRoutes } from '../message-queue/routes.js';
+import { getBrowserProviderHost } from '../browser-provider/host.js';
+import { registerBrowserProviderRoutes } from '../browser-provider/routes.js';
+import { createBrowserProviderSelectionStore } from '../browser-provider/selection-store.js';
 import { registerSkillRoutes } from './skill-routes.js';
 import { registerPluginRoutes } from './plugin-routes.js';
 import { getNpmInfo, clearCache as clearNpmCache } from './npm-registry.js';
 import { parseNpmSpec, parsePathSpec, isExactSemver } from './plugin-spec.js';
 import { registerOpenCodeRoutes } from './routes.js';
 import { getProviderSources, removeProviderConfig } from './providers.js';
-import { getAgentSources, getAgentConfig, createAgent, updateAgent, deleteAgent } from './agents.js';
+import { getAgentSources, getAgentConfig, listDisabledAgentOverrides, createAgent, updateAgent, deleteAgent } from './agents.js';
 import { getCommandSources, createCommand, updateCommand, deleteCommand } from './commands.js';
 import { listMcpConfigs, getMcpConfig, createMcpConfig, updateMcpConfig, deleteMcpConfig } from './mcp.js';
 import { listSnippets, getSnippet, createSnippet, updateSnippet, deleteSnippet, expandSnippets } from './snippets.js';
@@ -113,6 +117,16 @@ export const createFeatureRoutesRuntime = (dependencies) => {
       isUnsafeSkillRelativePath,
       buildOpenCodeUrl,
       getOpenCodeAuthHeaders,
+      getIsExternalOpenCode = () => false,
+      getIsSharedOpenCodeService = () => false,
+      forceResolvedOpenCodeBinary = null,
+      restartOpenCode = null,
+      getRuntimeContract = () => null,
+      getOpenCodeServeVersion = () => null,
+      getOpenCodeCliVersion = () => null,
+      getResolvedOpenCodeBinary = () => null,
+      getResolvedOpenCodeBinarySource = () => null,
+      getActiveSessionCount = () => 0,
       getSmallModelService: routeGetSmallModelService,
       getOpenCodePort,
       buildAugmentedPath,
@@ -132,6 +146,13 @@ export const createFeatureRoutesRuntime = (dependencies) => {
       getServerId,
       sessionIndexService,
       notifyContactTurnComplete,
+      sessionMetadataStore = null,
+      sessionArchiveService = null,
+      onSessionMetadataWritten = null,
+      persistSessionGoal = null,
+      persistSessionMetadata = null,
+      onSystemSessionPersisted = null,
+      readSessionMetadata = null,
     } = routeDependencies;
 
     registerSettingsUtilityRoutes(app, {
@@ -164,6 +185,18 @@ export const createFeatureRoutesRuntime = (dependencies) => {
       refreshOpenCodeAfterConfigChange,
       buildOpenCodeUrl,
       getOpenCodeAuthHeaders,
+      getIsExternalOpenCode,
+      getIsSharedOpenCodeService,
+      forceResolvedOpenCodeBinary,
+      restartOpenCode,
+      waitForOpenCodeReady,
+      getRuntimeContract,
+      getOpenCodeServeVersion,
+      getOpenCodeCliVersion,
+      getResolvedOpenCodeBinary,
+      getResolvedOpenCodeBinarySource,
+      getActiveSessionCount,
+      openchamberDataDir,
       onSettingsPersisted: (updated, changes) => {
         if (!questionAutoDelegateRuntime) return;
         if (!Object.prototype.hasOwnProperty.call(changes ?? {}, 'questionAutoDelegateEnabled')) return;
@@ -247,6 +280,8 @@ export const createFeatureRoutesRuntime = (dependencies) => {
     registerLlmRoutes(app, {
       buildOpenCodeUrl,
       getOpenCodeAuthHeaders,
+      persistSessionMetadata,
+      onSystemSessionPersisted,
     });
     assistantRoutesRuntime = registerAssistantRoutes(app, {
       openchamberDataDir,
@@ -273,6 +308,18 @@ export const createFeatureRoutesRuntime = (dependencies) => {
       },
       listScheduledTasks: (projectID) => projectConfigRuntime.listScheduledTasks(projectID),
       sessionIndexService,
+      archiveSessionHost: sessionArchiveService
+        ? async ({ sessionID, directory, archivedAt }) => sessionArchiveService.archiveSession(
+          sessionID,
+          directory,
+          archivedAt,
+        )
+        : null,
+      forgetSessionHost: sessionArchiveService
+        ? (sessionID) => sessionArchiveService.forgetSession(sessionID)
+        : null,
+      persistSessionMetadata,
+      onSystemSessionPersisted,
       upsertScheduledTask: (projectID, task) => projectConfigRuntime.upsertScheduledTask(projectID, task),
       syncScheduledTaskProject: (projectID) => scheduledTasksRuntime.syncProject(projectID),
       refreshAllowedRoots: refreshAssistantAllowedRoots,
@@ -293,9 +340,11 @@ export const createFeatureRoutesRuntime = (dependencies) => {
       resolveOptionalProjectDirectory,
       refreshOpenCodeAfterConfigChange,
       clientReloadDelayMs,
-      getAgentSources,
-      getAgentConfig,
-      createAgent,
+      waitForOpenCodeReady,
+    getAgentSources,
+    getAgentConfig,
+    listDisabledAgentOverrides,
+    createAgent,
       updateAgent,
       deleteAgent,
       getCommandSources,
@@ -387,7 +436,36 @@ export const createFeatureRoutesRuntime = (dependencies) => {
         throw new Error('Small model service is not configured');
       });
     registerSmallModelRoutes(app, { getSmallModelService });
-    registerSessionGoalRoutes(app);
+    registerSessionGoalRoutes(app, {
+      // Reuse the index-provided store seam — do not invent a second store.
+      persistSessionGoal: typeof persistSessionGoal === 'function'
+        ? persistSessionGoal
+        : (sessionMetadataStore
+          ? async (sessionId, _directory, goal) => {
+            const metadata = await sessionMetadataStore.setSessionMetadata(sessionId, {
+              openchamber: { goal },
+            });
+            return metadata;
+          }
+          : null),
+      readSessionMetadata: typeof readSessionMetadata === 'function'
+        ? readSessionMetadata
+        : (sessionMetadataStore
+          ? (sessionId) => sessionMetadataStore.get(sessionId)
+          : null),
+      // Same arm path as PUT /api/openchamber/sessions/:id/metadata.
+      onGoalPersisted: typeof onSessionMetadataWritten === 'function'
+        ? onSessionMetadataWritten
+        : null,
+    });
+    if (sessionMetadataStore) {
+      registerSessionMetadataRoutes(app, {
+        sessionMetadataStore,
+        sessionArchiveService,
+        broadcastGlobalUiEvent,
+        onMetadataWritten: onSessionMetadataWritten,
+      });
+    }
     registerGitHubRoutes(app);
     const broadcastOpenChamberEvent = createOpenChamberEventBroadcaster({
       getOpenChamberEventClients,
@@ -438,6 +516,13 @@ export const createFeatureRoutesRuntime = (dependencies) => {
       openchamberUserConfigRoot,
       openchamberDataDir,
     });
+    const browserProviderHost = getBrowserProviderHost();
+    if (typeof openchamberDataDir === 'string' && openchamberDataDir) {
+      browserProviderHost.attachSelectionStore(createBrowserProviderSelectionStore(
+        path.join(openchamberDataDir, 'browser-provider-selection.json'),
+      ));
+    }
+    registerBrowserProviderRoutes(app, { host: browserProviderHost });
   };
 
   return {

package/server/lib/opencode/feature-routes-runtime.test.js

@@ -3,6 +3,20 @@ import { describe, expect, it, vi } from 'vitest';
 import { createWorktreeTopologyBroadcaster } from './feature-routes-runtime.js';
 
 describe('feature routes runtime composition', () => {
+  it('passes live shared-service ownership from the host to upgrade routes', async () => {
+    const host = await fs.readFile(new URL('../../index.js', import.meta.url), 'utf8');
+    const routes = await fs.readFile(new URL('./feature-routes-runtime.js', import.meta.url), 'utf8');
+    expect(host).toContain('getIsSharedOpenCodeService: () => openCodeLifecycleRuntime.isSharedOpenCodeService()');
+    expect(routes).toMatch(/getIsSharedOpenCodeService = \(\) => false,[\s\S]*\} = routeDependencies;/);
+    expect(routes).toMatch(/registerOpenCodeRoutes\(app, \{[^}]*getIsSharedOpenCodeService,/);
+  });
+
+  it('wires Host isolation persist into scheduled-task runtime from the composition root', async () => {
+    const source = await fs.readFile(new URL('../../index.js', import.meta.url), 'utf8');
+    expect(source).toMatch(/createScheduledTasksRuntime\(\{[\s\S]*persistSessionMetadata: persistSessionMetadataToStore/);
+    expect(source).toMatch(/createScheduledTasksRuntime\(\{[\s\S]*onSystemSessionPersisted: hideSystemSessionFromIndex/);
+  });
+
   it('wires scheduled-task upsert into assistant contact tools', async () => {
     const source = await fs.readFile(new URL('./feature-routes-runtime.js', import.meta.url), 'utf8');
     expect(source).toMatch(/registerAssistantRoutes\(app, \{[\s\S]*upsertScheduledTask:[\s\S]*projectConfigRuntime\.upsertScheduledTask/);
@@ -10,6 +24,10 @@ describe('feature routes runtime composition', () => {
     expect(source).toMatch(/registerAssistantRoutes\(app, \{[\s\S]*listProjects:/);
     expect(source).toMatch(/registerAssistantRoutes\(app, \{[\s\S]*listScheduledTasks:[\s\S]*projectConfigRuntime\.listScheduledTasks/);
     expect(source).toMatch(/registerAssistantRoutes\(app, \{[\s\S]*sessionIndexService/);
+    expect(source).toMatch(/registerAssistantRoutes\(app, \{[\s\S]*persistSessionMetadata/);
+    expect(source).toMatch(/registerAssistantRoutes\(app, \{[\s\S]*onSystemSessionPersisted/);
+    expect(source).toMatch(/registerLlmRoutes\(app, \{[\s\S]*persistSessionMetadata/);
+    expect(source).toMatch(/registerLlmRoutes\(app, \{[\s\S]*onSystemSessionPersisted/);
     expect(source).toMatch(/label: project\.label\.trim\(\)/);
   });
 
@@ -36,6 +54,13 @@ describe('feature routes runtime composition', () => {
     expect(source).toMatch(/registerScheduledTaskRoutes\(app, \{[\s\S]*runHistoryStore,/);
   });
 
+  it('registers browser provider routes on the shared host before proxy composition', async () => {
+    const source = await fs.readFile(new URL('./feature-routes-runtime.js', import.meta.url), 'utf8');
+    expect(source).toContain("import { registerBrowserProviderRoutes } from '../browser-provider/routes.js';");
+    expect(source).toContain('registerBrowserProviderRoutes(app, { host: browserProviderHost });');
+    expect(source).toContain('createBrowserProviderSelectionStore(');
+  });
+
   it('registers message queue routes with the injected service before proxy composition', async () => {
     const source = await fs.readFile(new URL('./feature-routes-runtime.js', import.meta.url), 'utf8');
     expect(source).toContain("import { registerMessageQueueRoutes } from '../message-queue/routes.js';");

package/server/lib/opencode/http-server-connections.js

@@ -0,0 +1,98 @@
+/**
+ * Track sockets owned by an HTTP server so force-close can destroy upgraded
+ * WebSocket/SSE sockets that Node's `server.closeAllConnections()` leaves open
+ * (those keep `server.close()` from firing until SHUTDOWN_TIMEOUT).
+ */
+
+export const HTTP_SERVER_CONNECTIONS = Symbol.for('openchamber.httpServerConnections');
+
+/**
+ * @param {import('node:http').Server} server
+ * @returns {{
+ *   getOpenSocketCount: () => number,
+ *   destroyRemainingSockets: () => number,
+ *   dispose: () => void,
+ * }}
+ */
+export const attachHttpServerConnectionTracker = (server) => {
+  if (!server || typeof server.on !== 'function') {
+    return {
+      getOpenSocketCount: () => 0,
+      destroyRemainingSockets: () => 0,
+      dispose: () => {},
+    };
+  }
+
+  const existing = server[HTTP_SERVER_CONNECTIONS];
+  if (existing && typeof existing.destroyRemainingSockets === 'function') {
+    return existing;
+  }
+
+  /** @type {Set<import('node:net').Socket>} */
+  const sockets = new Set();
+
+  const track = (socket) => {
+    if (!socket || sockets.has(socket)) return;
+    sockets.add(socket);
+    const release = () => {
+      sockets.delete(socket);
+    };
+    socket.once('close', release);
+    socket.once('error', release);
+  };
+
+  // Plain HTTP and pre-upgrade TCP both emit `connection`. After `upgrade`, the
+  // same socket object remains; tracking it here covers WS/SSE leftovers.
+  const onConnection = (socket) => {
+    track(socket);
+  };
+  server.on('connection', onConnection);
+
+  const api = {
+    getOpenSocketCount: () => sockets.size,
+    destroyRemainingSockets: () => {
+      let destroyed = 0;
+      for (const socket of [...sockets]) {
+        try {
+          if (!socket.destroyed) {
+            socket.destroy();
+            destroyed += 1;
+          }
+        } catch {
+        }
+        sockets.delete(socket);
+      }
+      return destroyed;
+    },
+    dispose: () => {
+      server.off?.('connection', onConnection);
+      sockets.clear();
+      try {
+        delete server[HTTP_SERVER_CONNECTIONS];
+      } catch {
+      }
+    },
+  };
+
+  server[HTTP_SERVER_CONNECTIONS] = api;
+  return api;
+};
+
+/**
+ * Stop accepting new connections, drop Node-tracked HTTP connections, then
+ * destroy any remaining server-owned sockets (including upgraded ones).
+ * @param {import('node:http').Server | null | undefined} server
+ * @returns {{ destroyedTracked: number }}
+ */
+export const forceCloseHttpServerConnections = (server) => {
+  if (!server) return { destroyedTracked: 0 };
+  try {
+    server.closeAllConnections?.();
+  } catch {
+  }
+  const tracker = server[HTTP_SERVER_CONNECTIONS];
+  const destroyedTracked = typeof tracker?.destroyRemainingSockets === 'function'
+    ? tracker.destroyRemainingSockets()
+    : 0;
+  return { destroyedTracked };
+};