@openchambery/web 2.0.0-beta.1 → 2.0.0-beta.4

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

@@ -50,7 +50,50 @@ const createDependencies = (getCommandSources, configDirectory, getAgentSources
   getOpenCodePort: () => 4096,
 });
 
+describe('V2 configuration persistence', () => {
+  it.each(['agents', 'commands', 'mcp'])('%s CRUD never restarts or reloads OpenCode', async (entity) => {
+    const dependencies = createDependencies(vi.fn());
+    dependencies.refreshOpenCodeAfterConfigChange.mockRejectedValue(new Error('must not manage the service'));
+    const app = express();
+    app.use(express.json());
+    registerConfigEntityRoutes(app, dependencies);
+    for (const method of ['post', 'patch', 'delete']) {
+      const response = await request(app)[method](`/api/config/${entity}/example?directory=%2Frepo`)
+        .send({ name: 'example', scope: 'project', type: 'local', command: ['example'] });
+      expect(response.status).toBe(200);
+      expect(response.body).toMatchObject({ success: true, requiresReload: false, application: 'watch' });
+      expect(response.body.requiresManualRestart).not.toBe(true);
+    }
+    expect(dependencies.refreshOpenCodeAfterConfigChange).not.toHaveBeenCalled();
+  });
+});
+
 describe('config entity command metadata route', () => {
+  it('preserves real SDK authentication and request options when fetching the catalog', async () => {
+    const { OpenCode: realOpenCode } = await vi.importActual('@opencode/client');
+    createOpencodeClient.mockImplementation(realOpenCode.make);
+    const upstream = vi.spyOn(globalThis, 'fetch').mockImplementation(async (_input, init) => {
+      if (new Headers(init?.headers).get('Authorization') !== 'Basic example') {
+        return new Response('Unauthorized', { status: 401 });
+      }
+      return Response.json({ data: [{ name: 'review', description: 'Review changes' }] });
+    });
+    try {
+      const app = express();
+      app.use(express.json());
+      registerConfigEntityRoutes(app, createDependencies(() => ({ md: { exists: false }, json: { exists: false } })));
+      const response = await request(app).post('/api/config/commands/metadata').send({ catalog: true });
+      expect(response.status).toBe(200);
+      expect(response.body.commands).toEqual([expect.objectContaining({ name: 'review' })]);
+      const [url, init] = upstream.mock.calls[0];
+      expect(new URL(url).pathname).toBe('/api/command');
+      expect(init.method).toBe('GET');
+      expect(init.signal).toBeInstanceOf(AbortSignal);
+    } finally {
+      upstream.mockRestore();
+    }
+  });
+
   it('returns metadata for many commands through one request', async () => {
     const app = express();
     app.use(express.json());
@@ -203,6 +246,70 @@ describe('provider catalog route', () => {
     expect(response.body).toEqual({ schemaVersion: 1, providers: [], default: {}, partial: false });
   });
 
+  it('projects ModelInfo.id as the catalog model id and default', async () => {
+    const app = express();
+    createOpencodeClient.mockReturnValue({
+      provider: { list: vi.fn(async () => ({ data: [{ id: 'openai', name: 'OpenAI' }] })) },
+      model: {
+        list: vi.fn(async () => ({
+          data: [{
+            id: 'gpt-5.4-mini',
+            modelID: 'internal-pack',
+            providerID: 'openai',
+            name: 'GPT-5.4 Mini',
+          }],
+        })),
+        default: vi.fn(async () => ({
+          data: { id: 'gpt-5.4-mini', modelID: 'internal-pack', providerID: 'openai', name: 'GPT-5.4 Mini' },
+        })),
+      },
+    });
+    registerConfigEntityRoutes(app, createDependencies(vi.fn()));
+
+    const response = await request(app).get('/api/config/catalog/providers').expect(200);
+    expect(response.body.providers).toEqual([{
+      id: 'openai',
+      name: 'OpenAI',
+      models: { 'gpt-5.4-mini': { id: 'gpt-5.4-mini', name: 'GPT-5.4 Mini' } },
+    }]);
+    expect(response.body.default).toEqual({ openai: 'gpt-5.4-mini' });
+    expect(JSON.stringify(response.body)).not.toContain('internal-pack');
+  });
+
+  it('projects v2 thinking variants into the provider catalog and strips request payloads', async () => {
+    const app = express();
+    createOpencodeClient.mockReturnValue({
+      provider: { list: vi.fn(async () => ({ data: [{ id: 'openai', name: 'OpenAI' }] })) },
+      model: {
+        list: vi.fn(async () => ({
+          data: [{
+            id: 'gpt-5.4',
+            modelID: 'internal-pack',
+            providerID: 'openai',
+            name: 'GPT 5.4',
+            capabilities: { tools: true, input: ['text', 'image'], output: ['text'] },
+            variants: [
+              { id: 'low', settings: { reasoningEffort: 'low', apiKey: 'variant-settings-sentinel' } },
+              { id: 'high', headers: { Authorization: 'variant-headers-sentinel' }, body: { store: false } },
+            ],
+          }],
+        })),
+        default: vi.fn(async () => ({ data: null })),
+      },
+    });
+    registerConfigEntityRoutes(app, createDependencies(vi.fn()));
+
+    const response = await request(app).get('/api/config/catalog/providers').expect(200);
+    expect(response.body.providers[0].models['gpt-5.4'].variants).toEqual({ low: {}, high: {} });
+    expect(response.body.providers[0].models['gpt-5.4'].capabilities).toEqual({
+      toolcall: true,
+      input: { text: true, image: true },
+      output: { text: true },
+    });
+    expect(JSON.stringify(response.body)).not.toContain('sentinel');
+    expect(JSON.stringify(response.body)).not.toContain('internal-pack');
+  });
+
   it('returns 502 for SDK failure and malformed catalog responses', async () => {
     const app = express();
     createOpencodeClient.mockReturnValue({

package/server/lib/opencode/config-hot-reload.integration.test.js

@@ -0,0 +1,105 @@
+import { test, expect } from 'vitest';
+import { OpenCode } from '@opencode/client';
+import { spawn } from 'node:child_process';
+import { once } from 'node:events';
+import { randomBytes } from 'node:crypto';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+// Opt-in, isolated real V2 server. No user config, credentials, model calls,
+// shared service registration, or npm plugin installs are used.
+test.skipIf(!process.env.OPENCHAMBER_TEST_OPENCODE_BINARY)('V2 applies credentials, global config and plugin changes in the same process', async () => {
+  const temporary = path.join(os.tmpdir(), 'opencode');
+  await fs.mkdir(temporary, { recursive: true });
+  const root = await fs.mkdtemp(path.join(temporary, 'config-hot-reload-'));
+  const config = path.join(root, 'config', 'opencode');
+  const directory = path.join(root, 'project');
+  await fs.mkdir(config, { recursive: true });
+  await fs.mkdir(directory, { recursive: true });
+  const password = randomBytes(24).toString('hex');
+  const child = spawn(process.env.OPENCHAMBER_TEST_OPENCODE_BINARY, ['serve', '--hostname', '127.0.0.1', '--port', '0'], {
+    cwd: directory,
+    env: {
+      PATH: process.env.PATH,
+      HOME: root,
+      TMPDIR: temporary,
+      XDG_CONFIG_HOME: path.join(root, 'config'),
+      XDG_DATA_HOME: path.join(root, 'data'),
+      XDG_STATE_HOME: path.join(root, 'state'),
+      XDG_CACHE_HOME: path.join(root, 'cache'),
+      OPENCODE_CONFIG_DIR: config,
+      OPENCODE_SERVER_PASSWORD: password,
+      OPENCODE_DISABLE_MODELS_FETCH: '1',
+    },
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+  let output = '';
+  let spawnError;
+  child.on('error', (error) => { spawnError = error; });
+  child.stdout.on('data', (data) => { output = (output + data).slice(-8192); });
+  child.stderr.on('data', () => undefined);
+  const closed = once(child, 'close').catch(() => undefined);
+  const until = async (read, accepts, label) => {
+    const deadline = Date.now() + 20_000;
+    while (Date.now() < deadline) {
+      if (spawnError) throw spawnError;
+      if (child.exitCode !== null) throw new Error(`Isolated OpenCode exited during ${label}`);
+      const value = await read();
+      if (accepts(value)) return value;
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    throw new Error(`Timed out waiting for ${label}`);
+  };
+  const write = async (info) => {
+    const file = path.join(config, 'opencode.json');
+    await fs.writeFile(`${file}.tmp`, JSON.stringify(info));
+    await fs.rename(`${file}.tmp`, file);
+  };
+  try {
+    const origin = await until(
+      async () => output.match(/(?:server listening on|opencode server listening on) (http:\/\/[^\s]+)/)?.[1],
+      Boolean, 'listener',
+    );
+    const client = OpenCode.make({
+      baseUrl: origin,
+      headers: { Authorization: `Basic ${Buffer.from(`opencode:${password}`).toString('base64')}` },
+      fetch: (input, init) => fetch(input, { ...init, signal: AbortSignal.timeout(15_000) }),
+    });
+    const location = { directory };
+    await client.command.list({ location });
+    const pid = child.pid;
+    const commands = { 'hot-reload-probe': { template: 'Do not execute anything.', description: 'one' } };
+    await write({ commands });
+    await until(() => client.command.list({ location }), (result) => result.data.some((entry) => entry.name === 'hot-reload-probe'), 'global command create');
+    await write({ commands: { 'hot-reload-probe': { ...commands['hot-reload-probe'], description: 'two' } } });
+    await until(() => client.command.list({ location }), (result) => result.data.some((entry) => entry.name === 'hot-reload-probe' && entry.description === 'two'), 'command update');
+
+    await write({ commands, plugins: ['*', '-opencode.config.command'] });
+    await until(() => client.command.list({ location }), (result) => !result.data.some((entry) => entry.name === 'hot-reload-probe'), 'plugin disable');
+    await write({ commands });
+    await until(() => client.command.list({ location }), (result) => result.data.some((entry) => entry.name === 'hot-reload-probe'), 'plugin re-enable');
+
+    await client.integration.connect.key({ integrationID: 'anthropic', key: 'isolated-test-placeholder', location });
+    const integration = await until(() => client.integration.get({ integrationID: 'anthropic', location }),
+      (result) => result.data.connections.some((connection) => connection.type === 'credential'), 'credential connection');
+    for (const connection of integration.data.connections) {
+      if (connection.type === 'credential') await client.credential.remove({ credentialID: connection.id });
+    }
+    await until(() => client.integration.get({ integrationID: 'anthropic', location }),
+      (result) => result.data.connections.length === 0, 'credential removal');
+    await write({ commands, mcp: { servers: { 'hot-reload-mcp': { type: 'local', command: ['unused-test-command'], disabled: true } } } });
+    await until(() => client.mcp.list({ location }), (result) => result.data.some((server) => server.name === 'hot-reload-mcp'), 'MCP config add');
+    await write({});
+    await until(() => client.mcp.list({ location }), (result) => !result.data.some((server) => server.name === 'hot-reload-mcp'), 'MCP config removal');
+    await until(() => client.command.list({ location }), (result) => !result.data.some((entry) => entry.name === 'hot-reload-probe'), 'command removal');
+    expect(child.pid).toBe(pid);
+    expect(child.exitCode).toBeNull();
+  } finally {
+    child.kill('SIGTERM');
+    const kill = setTimeout(() => child.kill('SIGKILL'), 5000);
+    await closed;
+    clearTimeout(kill);
+    await fs.rm(root, { recursive: true, force: true });
+  }
+}, 120_000);

package/server/lib/opencode/ensure-cli.js

@@ -180,8 +180,7 @@ export async function installPinnedOpenCode2Cli(options = {}) {
     });
   }
 
-  const extractedBinary = findBinary(extractDir, binaryName)
-    || findBinary(extractDir, platform === 'win32' ? 'opencode2.exe' : 'opencode2');
+  const extractedBinary = findBinary(extractDir, binaryName);
   if (!extractedBinary) {
     throw new Error(`Archive ${archivePath} did not contain ${binaryName} or opencode`);
   }

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

@@ -314,14 +314,6 @@ export const createOpenCodeEnvRuntime = (deps) => {
     return trimmed;
   };
 
-  const createOpenCode1xVersionError = (candidate, version) => {
-    const error = new Error(
-      `OpenCode 1.x is not supported (${candidate} reports ${version}). Install OpenCode v2 (opencode).`
-    );
-    error.code = 'OPENCODE_BINARY_INVALID';
-    return error;
-  };
-
   const acceptOpenCodeV2Candidate = (candidate, source) => {
     if (typeof candidate !== 'string' || !candidate.trim()) return null;
     if (!isExecutable(candidate) || isWindowsOpenCodeDesktopAppPath(candidate) || isMacOpenCodeAppBundlePath(candidate)) {
@@ -353,22 +345,25 @@ export const createOpenCodeEnvRuntime = (deps) => {
       if (!isExecutable(candidate)) continue;
       const version = readOpenCode2BinaryVersion(candidate);
       if (isOpenCode1xVersion(version)) {
-        throw createOpenCode1xVersionError(candidate, version);
+        // Inherited OPENCODE_BINARY often points at a still-installed 1.x.
+        // Skip it and keep looking; never overwrite that binary.
+        console.warn(`Skipping OpenCode 1.x at ${candidate} (${version}); looking for v2.`);
+        continue;
       }
       const accepted = acceptOpenCodeV2Candidate(candidate, 'env');
       if (accepted) return accepted;
     }
 
     // Match master: reuse a globally installed CLI. Official v2 is `opencode`;
-    // `opencode2` remains a compatibility alias. Skip 1.x binaries by version.
-    for (const name of process.platform === 'win32' ? ['opencode', 'opencode2'] : ['opencode', 'opencode2']) {
+    // Skip 1.x binaries by version; auto-discovery uses only the official name.
+    for (const name of ['opencode']) {
       const resolvedFromPath = searchPathFor(name);
       const accepted = acceptOpenCodeV2Candidate(resolvedFromPath, 'path');
       if (accepted) return accepted;
     }
 
     const home = resolveHomeDir();
-    const unixFallbacks = ['opencode', 'opencode2'].flatMap((name) => [
+    const unixFallbacks = ['opencode'].flatMap((name) => [
       path.join(home, '.opencode', 'bin', name),
       path.join(home, '.bun', 'bin', name),
       path.join(home, '.local', 'bin', name),
@@ -386,7 +381,7 @@ export const createOpenCodeEnvRuntime = (deps) => {
       const localAppData = process.env.LOCALAPPDATA || '';
       const programData = process.env.ProgramData || 'C:\\ProgramData';
       const programFiles = process.env.ProgramFiles || 'C:\\Program Files';
-      const names = ['opencode.exe', 'opencode.cmd', 'opencode2.exe', 'opencode2.cmd'];
+      const names = ['opencode.exe', 'opencode.cmd'];
       const dirs = [
         path.join(userProfile, '.opencode', 'bin'),
         path.join(appData, 'npm'),
@@ -405,7 +400,7 @@ export const createOpenCodeEnvRuntime = (deps) => {
     }
 
     if (process.platform === 'win32') {
-      for (const name of ['opencode', 'opencode2']) {
+      for (const name of ['opencode']) {
         try {
           const result = runSpawnSync('where', [name], {
             encoding: 'utf8',
@@ -432,7 +427,7 @@ export const createOpenCodeEnvRuntime = (deps) => {
     }
 
     const shells = [process.env.SHELL, '/bin/zsh', '/bin/bash', '/bin/sh'].filter(Boolean);
-    for (const name of ['opencode', 'opencode2']) {
+    for (const name of ['opencode']) {
       for (const shell of shells) {
         if (!isExecutable(shell)) continue;
         try {
@@ -1023,10 +1018,7 @@ export const createOpenCodeEnvRuntime = (deps) => {
       if (normalized && isExecutable(normalized)) {
         const version = readOpenCode2BinaryVersion(normalized);
         if (isOpenCode1xVersion(version)) {
-          if (strict) {
-            throw createOpenCode1xVersionError(normalized, version);
-          }
-          console.warn(`Configured settings.opencodeBinary points at OpenCode 1.x, which OpenChamber refuses: ${normalized}`);
+          console.warn(`Skipping configured OpenCode 1.x at ${normalized} (${version}); looking for v2.`);
           return null;
         }
       }
@@ -1061,15 +1053,16 @@ export const createOpenCodeEnvRuntime = (deps) => {
       if (state.useWslForOpencode) {
         return state.resolvedOpencodeBinary;
       }
+      process.env.OPENCODE_BINARY = state.resolvedOpencodeBinary;
       ensureOpencodeShimRuntime(state.resolvedOpencodeBinary);
       return state.resolvedOpencodeBinary;
     }
 
     const existing = typeof process.env.OPENCODE_BINARY === 'string' ? process.env.OPENCODE_BINARY.trim() : '';
     if (existing && isExecutable(existing) && isOpenCode1xVersion(readOpenCode2BinaryVersion(existing))) {
-      throw createOpenCode1xVersionError(existing, readOpenCode2BinaryVersion(existing));
-    }
-    if (existing && isExecutable(existing)) {
+      console.warn(`Ignoring OpenCode 1.x OPENCODE_BINARY at ${existing}; looking for v2.`);
+      delete process.env.OPENCODE_BINARY;
+    } else if (existing && isExecutable(existing)) {
       clearWslOpencodeResolution();
       state.resolvedOpencodeBinary = existing;
       state.resolvedOpencodeBinarySource = state.resolvedOpencodeBinarySource || 'env';
@@ -1113,8 +1106,8 @@ export const createOpenCodeEnvRuntime = (deps) => {
       dirs.push(path.join(process.resourcesPath, 'opencode-cli'));
     }
 
-    // Official v2 name + packaging contract name (see electron opencode2-bundle-contract).
-    const names = ['opencode', 'opencode.exe', 'opencode2', 'opencode2.exe'];
+    // Runtime and packaging use the official v2 executable name.
+    const names = ['opencode', 'opencode.exe'];
     for (const dir of dirs) {
       for (const name of names) {
         const accepted = acceptOpenCodeV2Candidate(path.join(dir, name), 'bundled');
@@ -1141,11 +1134,11 @@ export const createOpenCodeEnvRuntime = (deps) => {
       if (!result?.path) {
         return ensureOpencodeCliEnv();
       }
-      if (result.source === 'installed') {
+      if (result.path) {
         clearWslOpencodeResolution();
         process.env.OPENCODE_BINARY = result.path;
         state.resolvedOpencodeBinary = result.path;
-        state.resolvedOpencodeBinarySource = 'installed';
+        state.resolvedOpencodeBinarySource = result.source === 'installed' ? 'installed' : (state.resolvedOpencodeBinarySource || 'discovered');
       }
       return ensureOpencodeCliEnv();
     } catch (error) {
@@ -1241,6 +1234,26 @@ export const createOpenCodeEnvRuntime = (deps) => {
     state.resolvedOpencodeBinary = null;
   };
 
+  /**
+   * Pin managed launch to an explicit binary for the duration of an owned-cache
+   * upgrade (ticket 12). Avoids rediscovery that would re-attach a global CLI.
+   */
+  const forceResolvedOpenCodeBinary = (binaryPath, source = 'installed') => {
+    const trimmed = typeof binaryPath === 'string' ? binaryPath.trim() : '';
+    if (!trimmed) {
+      const error = new Error('forceResolvedOpenCodeBinary requires a binary path');
+      error.code = 'OPENCODE_BINARY_INVALID';
+      throw error;
+    }
+    clearWslOpencodeResolution();
+    process.env.OPENCODE_BINARY = trimmed;
+    state.resolvedOpencodeBinary = trimmed;
+    state.resolvedOpencodeBinarySource = source || 'installed';
+    prependToPath(path.dirname(trimmed));
+    ensureOpencodeShimRuntime(trimmed);
+    return trimmed;
+  };
+
   return {
     applyLoginShellEnvSnapshot,
     ensureOpencodeCliEnv,
@@ -1253,5 +1266,6 @@ export const createOpenCodeEnvRuntime = (deps) => {
     searchPathFor,
     resolveGitBinaryForSpawn,
     clearResolvedOpenCodeBinary,
+    forceResolvedOpenCodeBinary,
   };
 };

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

@@ -168,31 +168,24 @@ describe('OpenCode env runtime', () => {
     expect(state.resolvedOpencodeBinarySource).toBe('settings');
   });
 
-  it('rejects a configured 1.x opencode version in strict mode', async () => {
+  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 })).rejects.toMatchObject({
-      code: 'OPENCODE_BINARY_INVALID',
-      message: expect.stringMatching(/1\.x.*OpenCode v2/s),
-    });
+    await expect(runtime.applyOpencodeBinaryFromSettings({ strict: true })).resolves.toBeNull();
+    expect(process.env.OPENCODE_BINARY).not.toBe(binary);
   });
 
-  it('rejects an explicit OPENCODE_BINARY that reports a 1.x version', () => {
+  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()).toThrow(
-      expect.objectContaining({
-        code: 'OPENCODE_BINARY_INVALID',
-        message: expect.stringMatching(/1\.x.*OpenCode v2/s),
-      })
-    );
+    expect(runtime.resolveOpencodeCliPath()).not.toBe(binary);
   });
 
   it('discovers opencode from a home-directory install location', () => {
@@ -233,7 +226,7 @@ describe('OpenCode env runtime', () => {
 
   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' ? 'opencode2.exe' : 'opencode2');
+    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');
@@ -252,7 +245,7 @@ describe('OpenCode env runtime', () => {
 
   it('keeps explicit OpenCode binary ahead of bundled CLI', () => {
     const bundledDir = createTempDir('openchamber-bundled-opencode-');
-    const bundledBinary = path.join(bundledDir, process.platform === 'win32' ? 'opencode2.exe' : 'opencode2');
+    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' ? 'opencode2.exe' : 'opencode2');
     fs.writeFileSync(bundledBinary, '#!/bin/sh\nexit 0\n');
@@ -271,7 +264,7 @@ describe('OpenCode env runtime', () => {
   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' ? 'opencode2.exe' : 'opencode2');
+    const bundledBinary = path.join(bundledDir, process.platform === 'win32' ? 'opencode.exe' : 'opencode');
     fs.mkdirSync(bundledDir, { recursive: true });
     fs.writeFileSync(bundledBinary, '#!/bin/sh\nexit 0\n');
     if (process.platform !== 'win32') {
@@ -346,7 +339,7 @@ describe('OpenCode env runtime', () => {
 
   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' ? 'opencode2.exe' : 'opencode2';
+    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;
@@ -395,7 +388,7 @@ describe('OpenCode env runtime', () => {
 
   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' ? 'opencode2.exe' : 'opencode2';
+    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;

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

@@ -25,7 +25,7 @@ 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';
@@ -115,6 +115,15 @@ export const createFeatureRoutesRuntime = (dependencies) => {
       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,
@@ -135,8 +144,11 @@ export const createFeatureRoutesRuntime = (dependencies) => {
       sessionIndexService,
       notifyContactTurnComplete,
       sessionMetadataStore = null,
+      sessionArchiveService = null,
       onSessionMetadataWritten = null,
       persistSessionGoal = null,
+      persistSessionMetadata = null,
+      onSystemSessionPersisted = null,
       readSessionMetadata = null,
     } = routeDependencies;
 
@@ -171,6 +183,17 @@ export const createFeatureRoutesRuntime = (dependencies) => {
       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;
@@ -254,6 +277,8 @@ export const createFeatureRoutesRuntime = (dependencies) => {
     registerLlmRoutes(app, {
       buildOpenCodeUrl,
       getOpenCodeAuthHeaders,
+      persistSessionMetadata,
+      onSystemSessionPersisted,
     });
     assistantRoutesRuntime = registerAssistantRoutes(app, {
       openchamberDataDir,
@@ -280,6 +305,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,
@@ -301,9 +338,10 @@ export const createFeatureRoutesRuntime = (dependencies) => {
       refreshOpenCodeAfterConfigChange,
       clientReloadDelayMs,
       waitForOpenCodeReady,
-      getAgentSources,
-      getAgentConfig,
-      createAgent,
+    getAgentSources,
+    getAgentConfig,
+    listDisabledAgentOverrides,
+    createAgent,
       updateAgent,
       deleteAgent,
       getCommandSources,
@@ -420,6 +458,7 @@ export const createFeatureRoutesRuntime = (dependencies) => {
     if (sessionMetadataStore) {
       registerSessionMetadataRoutes(app, {
         sessionMetadataStore,
+        sessionArchiveService,
         broadcastGlobalUiEvent,
         onMetadataWritten: onSessionMetadataWritten,
       });

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\(\)/);
   });