@vantran-se/openchamber-web 1.24.3 → 2.0.1

package/server/lib/opencode/shared.js

@@ -3,17 +3,21 @@ import path from 'path';
 import os from 'os';
 import yaml from 'yaml';
 import { parse as parseJsonc, printParseErrorCode } from 'jsonc-parser';
+import { readSectionEntry, readMcpEntry } from './config-v2.js';
 
 // ============== PATH CONSTANTS ==============
 
-const OPENCODE_CONFIG_DIR = path.join(
-  process.env.XDG_CONFIG_HOME?.trim() || path.join(os.homedir(), '.config'),
-  'opencode',
-);
+// OpenCode 2 resolves its global config directory as `OPENCODE_CONFIG_DIR`
+// when set, else `$XDG_CONFIG_HOME/opencode`, else `~/.config/opencode`.
+const OPENCODE_CONFIG_DIR = process.env.OPENCODE_CONFIG_DIR?.trim()
+  ? path.resolve(process.env.OPENCODE_CONFIG_DIR.trim())
+  : path.join(process.env.XDG_CONFIG_HOME?.trim() || path.join(os.homedir(), '.config'), 'opencode');
 const AGENT_DIR = path.join(OPENCODE_CONFIG_DIR, 'agents');
 const COMMAND_DIR = path.join(OPENCODE_CONFIG_DIR, 'commands');
 const SKILL_DIR = path.join(OPENCODE_CONFIG_DIR, 'skills');
-const CONFIG_FILE = path.join(OPENCODE_CONFIG_DIR, 'config.json');
+// OpenCode 2 reads only `opencode.json(c)`; the v1-era `config.json` is not
+// discovered any more, so it is neither read nor written here.
+const CONFIG_FILE = path.join(OPENCODE_CONFIG_DIR, 'opencode.json');
 const PROMPT_FILE_PATTERN = /^\{file:(.+)\}$/i;
 
 // ============== SCOPE TYPE CONSTANTS ==============
@@ -122,13 +126,21 @@ function writeMdFile(filePath, frontmatter, body) {
 
 // ============== CONFIG FILE OPERATIONS ==============
 
+/**
+ * Project config files in the order OpenCode 2 lets them win: a file under
+ * `.opencode/` overrides the one beside it at the project root, and
+ * `opencode.json` overrides `opencode.jsonc`. When several exist, the
+ * highest-priority one is the file OpenChamber reads and writes for the
+ * project scope (OpenCode merges them all; an entry that lives only in a
+ * lower file is visible through the resolved catalog but not editable here).
+ */
 function getProjectConfigCandidates(workingDirectory) {
   if (!workingDirectory) return [];
   return [
-    path.join(workingDirectory, 'opencode.json'),
-    path.join(workingDirectory, 'opencode.jsonc'),
     path.join(workingDirectory, '.opencode', 'opencode.json'),
     path.join(workingDirectory, '.opencode', 'opencode.jsonc'),
+    path.join(workingDirectory, 'opencode.json'),
+    path.join(workingDirectory, 'opencode.jsonc'),
   ];
 }
 
@@ -143,13 +155,13 @@ function getProjectConfigPath(workingDirectory) {
     }
   }
 
+  // A new project config goes beside the project's other `.opencode/` files.
   return candidates[0];
 }
 
 function getConfigPaths(workingDirectory) {
   return {
     userPaths: [
-      path.join(OPENCODE_CONFIG_DIR, 'config.json'),
       path.join(OPENCODE_CONFIG_DIR, 'opencode.json'),
       path.join(OPENCODE_CONFIG_DIR, 'opencode.jsonc'),
     ],
@@ -357,30 +369,49 @@ function throwIfLayerError(layers, filePath) {
   throw error;
 }
 
-function getJsonEntrySource(layers, sectionKey, entryName) {
+/**
+ * Look one entry up in a config layer, accepting both OpenCode 2 section keys
+ * and the v1 keys v2 still decodes. `sectionKind` is `agents`, `commands`,
+ * `providers`, or `mcp`.
+ */
+function lookupSectionEntry(config, sectionKind, entryName) {
+  if (sectionKind === 'mcp') {
+    return readMcpEntry(config, entryName);
+  }
+  return readSectionEntry(config, sectionKind, entryName);
+}
+
+function getJsonEntrySource(layers, sectionKind, entryName) {
   const { userConfig, projectConfig, customConfig, paths } = layers;
+  const found = (config, filePath) => {
+    const entry = lookupSectionEntry(config, sectionKind, entryName);
+    if (entry.value === undefined) return null;
+    return {
+      section: entry.value,
+      config,
+      path: filePath,
+      exists: true,
+      sectionKey: entry.key,
+      legacy: entry.legacy,
+    };
+  };
+
   if (paths.customPath) {
     throwIfLayerError(layers, paths.customPath);
-    const customSection = customConfig?.[sectionKey]?.[entryName];
-    if (customSection !== undefined) {
-      return { section: customSection, config: customConfig, path: paths.customPath, exists: true };
-    }
+    const custom = found(customConfig, paths.customPath);
+    if (custom) return custom;
   }
 
   if (paths.projectPath && !getLayerError(layers, paths.projectPath)) {
-    const projectSection = projectConfig?.[sectionKey]?.[entryName];
-    if (projectSection !== undefined) {
-      return { section: projectSection, config: projectConfig, path: paths.projectPath, exists: true };
-    }
+    const project = found(projectConfig, paths.projectPath);
+    if (project) return project;
   }
 
   throwIfLayerError(layers, paths.userPath);
-  const userSection = userConfig?.[sectionKey]?.[entryName];
-  if (userSection !== undefined) {
-    return { section: userSection, config: userConfig, path: paths.userPath, exists: true };
-  }
+  const user = found(userConfig, paths.userPath);
+  if (user) return user;
 
-  return { section: null, config: null, path: null, exists: false };
+  return { section: null, config: null, path: null, exists: false, sectionKey: null, legacy: false };
 }
 
 function getJsonWriteTarget(layers, preferredScope) {
@@ -659,6 +690,7 @@ export {
   readConfig,
   getConfigForPath,
   writeConfig,
+  lookupSectionEntry,
   getJsonEntrySource,
   getJsonWriteTarget,
   getAncestors,

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

@@ -165,10 +165,12 @@ describe('updateAgent frontmatter preservation', () => {
     expect(content.match(/^---\r?\n/g)).toHaveLength(1);
 
     const parsed = parseMdFile(agentPath);
+    // `temperature` is a v1 field: reading accepts it, writing moves it under
+    // the v2 `request.body` overlay.
     expect(parsed.frontmatter).toEqual({
       description: 'Strategy agent',
       model: 'openai/gpt-5',
-      temperature: 0.7,
+      request: { body: { temperature: 0.7 } },
     });
     expect(parsed.body).toBe('');
   });
@@ -196,7 +198,7 @@ describe('updateAgent frontmatter preservation', () => {
     expect(parsed.frontmatter).toEqual({
       description: 'Updated strategy agent',
       mode: 'primary',
-      temperature: 0.7,
+      request: { body: { temperature: 0.7 } },
     });
     expect(parsed.body).toBe('Body of strateg.');
   });
@@ -372,10 +374,12 @@ describe('readConfigFile / writeConfig JSONC safety (issue #2923)', () => {
         }),
       ]);
 
-      updateMcpConfig('openproject', { enabled: false }, projectDir);
+      updateMcpConfig('openproject', { disabled: true }, projectDir);
       const rewritten = JSON.parse(fs.readFileSync(custom, 'utf8'));
       expect(rewritten.plugin).toEqual(['opencode-see-image']);
-      expect(rewritten.mcp.openproject.enabled).toBe(false);
+      // The v1 `mcp.<name>` entry is rewritten in place into `mcp.servers`.
+      expect(rewritten.mcp.openproject).toBeUndefined();
+      expect(rewritten.mcp.servers.openproject.disabled).toBe(true);
       expect(fs.readFileSync(projectFile, 'utf8')).toBe(PARTIAL_PARSE_CONFIG);
       expect(fs.existsSync(`${projectFile}.openchamber.backup`)).toBe(false);
     } finally {

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

@@ -31,25 +31,67 @@ export const createGracefulShutdownRuntime = (dependencies) => {
     getActiveTunnelController,
     setActiveTunnelController,
     tunnelAuthController,
+    beginGuestServiceShutdown,
+    stopAllGuestServices,
+    getGuestSurfaceRuntime,
+    getRealtimeProxyRuntime,
+    getDictationRuntime,
+    getRelayService,
+    getRelayReconcileTimer,
   } = dependencies;
 
   let shutdownPromise = null;
+  const serverConnections = new Set();
+  let closingHttpServer = false;
+
+  // Track TCP sockets before listen(): HTTP stops tracking them on upgrade,
+  // even when no WebSocket handler completes the handshake.
+  const trackServerConnections = (server) => {
+    const onConnection = (socket) => {
+      if (closingHttpServer) {
+        socket.destroy();
+        return;
+      }
+      serverConnections.add(socket);
+      socket.once('close', () => serverConnections.delete(socket));
+    };
+    server.on('connection', onConnection);
+    server.once('close', () => server.off('connection', onConnection));
+  };
 
   const runShutdown = async (options = {}) => {
     if (getIsShuttingDown()) return;
 
     setIsShuttingDown(true);
+    beginGuestServiceShutdown();
     syncToHmrState();
     console.log('Starting graceful shutdown...');
     const exitProcess = typeof options.exitProcess === 'boolean' ? options.exitProcess : getExitOnShutdown();
 
-    openCodeWatcherRuntime.stop();
-    sessionRuntime.dispose();
-    sessionAssistRuntime?.stop?.();
-    sessionGoalRuntime?.stop?.();
-    contextObligatoryRuntime?.stop?.();
-    messageQueueRuntime?.stop?.();
-    scheduledTasksRuntime?.stop?.();
+    // Both embedded stop() and daemon exits use this sequence. Close admission
+    // synchronously above, then stop viewers before draining their services.
+    const cleanupOperations = [
+      () => clearInterval(getRelayReconcileTimer()),
+      () => getGuestSurfaceRuntime()?.stop(),
+      () => getRealtimeProxyRuntime()?.stop(),
+      () => getRelayService()?.stop(),
+      () => getDictationRuntime()?.stop(),
+      () => openCodeWatcherRuntime.stop(),
+      () => sessionRuntime.dispose(),
+      () => sessionAssistRuntime?.stop?.(),
+      () => sessionGoalRuntime?.stop?.(),
+      () => contextObligatoryRuntime?.stop?.(),
+      () => messageQueueRuntime?.stop?.(),
+      () => scheduledTasksRuntime?.stop?.(),
+      stopAllGuestServices,
+    ];
+    for (const cleanup of cleanupOperations) {
+      try {
+        await cleanup();
+      } catch {
+        // One failed runtime must not skip the rest of host teardown.
+      }
+    }
 
     const healthCheckInterval = getHealthCheckInterval();
     if (healthCheckInterval) {
@@ -100,6 +142,7 @@ export const createGracefulShutdownRuntime = (dependencies) => {
 
     const server = getServer();
     if (server) {
+      closingHttpServer = true;
       let closeTimeout = null;
       try {
         await Promise.race([
@@ -111,6 +154,9 @@ export const createGracefulShutdownRuntime = (dependencies) => {
             // The backend has stopped. Active SSE/HTTP clients must not keep
             // Desktop waiting for the outer shutdown deadline.
             server.closeAllConnections?.();
+            // Includes upgraded sockets and reconnects accepted while the
+            // services above were draining. No child-process grace is cut short.
+            for (const socket of serverConnections) socket.destroy();
           }),
           new Promise((resolve) => {
             closeTimeout = setTimeout(() => {
@@ -154,5 +200,6 @@ export const createGracefulShutdownRuntime = (dependencies) => {
 
   return {
     gracefulShutdown,
+    trackServerConnections,
   };
 };

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

@@ -1,37 +1,51 @@
 import { afterEach, describe, expect, it, vi } from 'vitest';
 import http from 'node:http';
+import net from 'node:net';
+import { once } from 'node:events';
 
 import { createGracefulShutdownRuntime } from './shutdown-runtime.js';
 
-const createRuntime = (server) => createGracefulShutdownRuntime({
-  process: { exit: vi.fn() },
-  shutdownTimeoutMs: 1000,
-  getExitOnShutdown: () => false,
-  getIsShuttingDown: () => false,
-  setIsShuttingDown: vi.fn(),
-  syncToHmrState: vi.fn(),
-  openCodeWatcherRuntime: { stop: vi.fn() },
-  sessionRuntime: { dispose: vi.fn() },
-  scheduledTasksRuntime: { stop: vi.fn() },
-  getHealthCheckInterval: () => null,
-  clearHealthCheckInterval: vi.fn(),
-  getTerminalRuntime: () => null,
-  setTerminalRuntime: vi.fn(),
-  getMessageStreamRuntime: () => null,
-  setMessageStreamRuntime: vi.fn(),
-  shouldSkipOpenCodeStop: () => true,
-  getOpenCodePort: () => null,
-  getOpenCodeProcess: () => null,
-  setOpenCodeProcess: vi.fn(),
-  killProcessOnPort: vi.fn(),
-  waitForPortRelease: vi.fn(async () => true),
-  getServer: () => server,
-  getUiAuthController: () => null,
-  setUiAuthController: vi.fn(),
-  getActiveTunnelController: () => null,
-  setActiveTunnelController: vi.fn(),
-  tunnelAuthController: { clearActiveTunnel: vi.fn() },
-});
+const createRuntime = (server, overrides = {}) => {
+  const runtime = createGracefulShutdownRuntime({
+    process: { exit: vi.fn() },
+    shutdownTimeoutMs: 1000,
+    getExitOnShutdown: () => false,
+    getIsShuttingDown: () => false,
+    setIsShuttingDown: vi.fn(),
+    syncToHmrState: vi.fn(),
+    openCodeWatcherRuntime: { stop: vi.fn() },
+    sessionRuntime: { dispose: vi.fn() },
+    scheduledTasksRuntime: { stop: vi.fn() },
+    getHealthCheckInterval: () => null,
+    clearHealthCheckInterval: vi.fn(),
+    getTerminalRuntime: () => null,
+    setTerminalRuntime: vi.fn(),
+    getMessageStreamRuntime: () => null,
+    setMessageStreamRuntime: vi.fn(),
+    shouldSkipOpenCodeStop: () => true,
+    getOpenCodePort: () => null,
+    getOpenCodeProcess: () => null,
+    setOpenCodeProcess: vi.fn(),
+    killProcessOnPort: vi.fn(),
+    waitForPortRelease: vi.fn(async () => true),
+    getServer: () => server,
+    getUiAuthController: () => null,
+    setUiAuthController: vi.fn(),
+    getActiveTunnelController: () => null,
+    setActiveTunnelController: vi.fn(),
+    tunnelAuthController: { clearActiveTunnel: vi.fn() },
+    beginGuestServiceShutdown: vi.fn(),
+    stopAllGuestServices: vi.fn(),
+    getGuestSurfaceRuntime: () => null,
+    getRealtimeProxyRuntime: () => null,
+    getDictationRuntime: () => null,
+    getRelayService: () => null,
+    getRelayReconcileTimer: () => null,
+    ...overrides,
+  });
+  if (server instanceof http.Server) runtime.trackServerConnections(server);
+  return runtime;
+};
 
 describe('graceful shutdown runtime', () => {
   afterEach(() => {
@@ -62,6 +76,7 @@ describe('graceful shutdown runtime', () => {
       response.writeHead(200, { 'content-type': 'text/event-stream' });
       response.write('data: fixture\n\n');
     });
+    const runtime = createRuntime(server);
     await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
     const request = http.get(`http://127.0.0.1:${server.address().port}`);
     request.on('error', () => {});
@@ -70,7 +85,7 @@ describe('graceful shutdown runtime', () => {
     const closed = new Promise((resolve) => response.once('close', resolve));
     const warning = vi.spyOn(console, 'warn').mockImplementation(() => {});
     try {
-      await createRuntime(server).gracefulShutdown({ exitProcess: false });
+      await runtime.gracefulShutdown({ exitProcess: false });
       expect(warning).not.toHaveBeenCalledWith('Server close timeout reached, forcing shutdown');
       await closed;
     } finally {
@@ -79,4 +94,183 @@ describe('graceful shutdown runtime', () => {
       await new Promise((resolve) => server.close(resolve));
     }
   });
+
+  it.each([false, true])('closes upgraded sockets without the HTTP timeout (handshake completed: %s)', async (completeHandshake) => {
+    const server = http.createServer();
+    const runtime = createRuntime(server);
+    const sockets = new Set();
+    server.on('upgrade', (_request, socket) => {
+      sockets.add(socket);
+      if (completeHandshake) {
+        socket.write('HTTP/1.1 101 Switching Protocols\r\nConnection: Upgrade\r\nUpgrade: websocket\r\n\r\n');
+      }
+      // A listener for another WS route can leave the upgrade unanswered.
+    });
+    await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+    const client = net.connect(server.address().port, '127.0.0.1');
+    client.on('error', () => {});
+    client.resume();
+    const clientClosed = once(client, 'close');
+    const upgraded = once(server, 'upgrade');
+    client.write('GET /api/global/event/ws HTTP/1.1\r\nHost: localhost\r\nConnection: Upgrade\r\nUpgrade: websocket\r\n\r\n');
+    await upgraded;
+    const warning = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    try {
+      await runtime.gracefulShutdown({ exitProcess: false });
+      expect(warning).not.toHaveBeenCalledWith('Server close timeout reached, forcing shutdown');
+      await clientClosed;
+      const connections = await new Promise((resolve, reject) => {
+        server.getConnections((error, count) => error ? reject(error) : resolve(count));
+      });
+      expect(connections).toBe(0);
+    } finally {
+      for (const socket of sockets) socket.destroy();
+      client.destroy();
+      await new Promise((resolve) => server.close(resolve));
+    }
+  });
+
+  it('drains processes before closing sockets accepted during cleanup, including after a cleanup failure', async () => {
+    const server = http.createServer();
+    const cleanupStarted = Promise.withResolvers();
+    const finishCleanup = Promise.withResolvers();
+    const sockets = new Set();
+    const clients = [];
+    server.on('upgrade', (_request, socket) => sockets.add(socket));
+    const terminalShutdown = vi.fn(async () => {
+      expect([...sockets].every((socket) => !socket.destroyed)).toBe(true);
+    });
+    const processClose = vi.fn(async () => {
+      expect(terminalShutdown).toHaveBeenCalledOnce();
+      expect([...sockets].every((socket) => !socket.destroyed)).toBe(true);
+    });
+    const runtime = createRuntime(server, {
+      stopAllGuestServices: async () => {
+        cleanupStarted.resolve();
+        await finishCleanup.promise;
+        throw new Error('fixture cleanup failure');
+      },
+      getTerminalRuntime: () => ({ shutdown: terminalShutdown }),
+      shouldSkipOpenCodeStop: () => false,
+      getOpenCodeProcess: () => ({ close: processClose }),
+    });
+    await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+    const shutdown = runtime.gracefulShutdown({ exitProcess: false });
+    expect(runtime.gracefulShutdown({ exitProcess: false })).toBe(shutdown);
+    await cleanupStarted.promise;
+    const warning = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    try {
+      const closed = [];
+      for (let index = 0; index < 8; index += 1) {
+        const client = net.connect(server.address().port, '127.0.0.1');
+        clients.push(client);
+        client.resume();
+        closed.push(once(client, 'close'));
+        const upgraded = once(server, 'upgrade');
+        client.write('GET /api/global/event/ws HTTP/1.1\r\nHost: localhost\r\nConnection: Upgrade\r\nUpgrade: websocket\r\n\r\n');
+        await upgraded;
+      }
+      expect(sockets.size).toBe(8);
+      expect(processClose).not.toHaveBeenCalled();
+      finishCleanup.resolve();
+      await shutdown;
+      expect(processClose).toHaveBeenCalledOnce();
+      expect(warning).not.toHaveBeenCalledWith('Server close timeout reached, forcing shutdown');
+      await Promise.all(closed);
+      expect(server.listening).toBe(false);
+    } finally {
+      finishCleanup.resolve();
+      for (const socket of sockets) socket.destroy();
+      for (const client of clients) client.destroy();
+      await shutdown;
+      await new Promise((resolve) => server.close(resolve));
+    }
+  });
+
+  it('stops guest services during shutdown', async () => {
+    const server = {
+      close: vi.fn((callback) => {
+        callback();
+      }),
+    };
+    const stopAllGuestServices = vi.fn(async () => {});
+
+    const runtime = createRuntime(server, { stopAllGuestServices });
+    await runtime.gracefulShutdown({ exitProcess: false });
+
+    expect(stopAllGuestServices).toHaveBeenCalledTimes(1);
+  });
+
+  it('continues shutdown when stopping guest services fails', async () => {
+    const server = {
+      close: vi.fn((callback) => {
+        callback();
+      }),
+    };
+    const stopAllGuestServices = vi.fn(async () => {
+      throw new Error('guest teardown failed');
+    });
+    const terminalRuntime = { shutdown: vi.fn(async () => {}) };
+
+    const runtime = createRuntime(server, {
+      stopAllGuestServices,
+      getTerminalRuntime: () => terminalRuntime,
+    });
+    await runtime.gracefulShutdown({ exitProcess: false });
+
+    expect(stopAllGuestServices).toHaveBeenCalledTimes(1);
+    expect(terminalRuntime.shutdown).toHaveBeenCalledTimes(1);
+    expect(server.close).toHaveBeenCalled();
+  });
+
+  it('closes guest admission synchronously and cleans every runtime once across repeated shutdown calls', async () => {
+    vi.useFakeTimers();
+    const order = [];
+    const cleanup = (name) => vi.fn(() => { order.push(name); });
+    const viewers = { stop: cleanup('viewers') };
+    const proxy = { stop: cleanup('proxy') };
+    const dictation = { stop: cleanup('dictation') };
+    const relay = { stop: cleanup('relay') };
+    const gate = cleanup('gate');
+    const guests = cleanup('guests');
+    const reconcile = vi.fn();
+    const timer = setInterval(reconcile, 100);
+    const runtime = createRuntime(null, {
+      beginGuestServiceShutdown: gate,
+      stopAllGuestServices: guests,
+      getGuestSurfaceRuntime: () => viewers,
+      getRealtimeProxyRuntime: () => proxy,
+      getDictationRuntime: () => dictation,
+      getRelayService: () => relay,
+      getRelayReconcileTimer: () => timer,
+    });
+    const first = runtime.gracefulShutdown();
+    expect(gate).toHaveBeenCalledTimes(1);
+    expect(runtime.gracefulShutdown()).toBe(first);
+    await first;
+    await runtime.gracefulShutdown();
+    expect(order).toEqual(['gate', 'viewers', 'proxy', 'relay', 'dictation', 'guests']);
+    await vi.advanceTimersByTimeAsync(200);
+    expect(reconcile).not.toHaveBeenCalled();
+    expect(vi.getTimerCount()).toBe(0);
+  });
+
+  it('isolates failed viewer and relay cleanup and still drains guests and exits', async () => {
+    const stop = vi.fn(() => { throw new Error('stop failed'); });
+    const stopAllGuestServices = vi.fn(async () => {});
+    const dictation = { stop: vi.fn() };
+    const process = { exit: vi.fn() };
+    const runtime = createRuntime(null, {
+      process,
+      getGuestSurfaceRuntime: () => ({ stop }),
+      getRelayService: () => ({ stop }),
+      getDictationRuntime: () => dictation,
+      stopAllGuestServices,
+    });
+    await runtime.gracefulShutdown({ exitProcess: true });
+    expect(stop).toHaveBeenCalledTimes(2);
+    expect(dictation.stop).toHaveBeenCalledTimes(1);
+    expect(stopAllGuestServices).toHaveBeenCalledTimes(1);
+    expect(process.exit).toHaveBeenCalledWith(0);
+  });
 });

package/server/lib/opencode/skill-routes.js

@@ -1,5 +1,5 @@
-import { createOpencodeClient } from '@opencode-ai/sdk/v2';
-import { buildDeferredRestartResponse } from './config-mutation-response.js';
+import { OpenCode } from '@opencode/client';
+import { buildAppliedResponse } from './config-mutation-response.js';
 import { OPENCODE_CONFIG_DIR } from './shared.js';
 
 /**
@@ -131,16 +131,18 @@ export const registerSkillRoutes = (app, dependencies) => {
     }
 
     try {
-      const client = createOpencodeClient({
+      const client = OpenCode.make({
         baseUrl: buildOpenCodeUrl('/', '').replace(/\/$/, ''),
-        directory: workingDirectory || undefined,
-        headers: getOpenCodeAuthHeaders(),
-        fetch: (request) => fetch(request, { signal: AbortSignal.timeout(8_000) }),
+        headers: {
+          ...getOpenCodeAuthHeaders(),
+          // v2 scopes a request with a header, not a `directory` option, and
+          // rejects non-ASCII header values, so the path is percent-encoded.
+          ...(workingDirectory ? { 'x-opencode-directory': encodeURIComponent(workingDirectory) } : {}),
+        },
+        fetch: (input, init) => fetch(input, { ...init, signal: AbortSignal.timeout(8_000) }),
       });
 
-      const response = await client.app.skills(
-        workingDirectory ? { directory: workingDirectory } : undefined,
-      );
+      const response = await client.skill.list();
       const payload = response?.data;
       if (!Array.isArray(payload)) {
         return [];
@@ -510,14 +512,14 @@ export const registerSkillRoutes = (app, dependencies) => {
 
       const installed = result.installed || [];
       const skipped = result.skipped || [];
-      const requiresRestart = installed.length > 0;
+      const installedAny = installed.length > 0;
 
       res.json({
         ok: true,
         installed,
         skipped,
-        ...(requiresRestart
-          ? buildDeferredRestartResponse('Skills installed successfully. Restart OpenCode to apply.')
+        ...(installedAny
+          ? buildAppliedResponse('Skills installed successfully.')
           : {
             requiresReload: false,
             message: 'No skills were installed',
@@ -602,8 +604,8 @@ export const registerSkillRoutes = (app, dependencies) => {
       console.log('[Server] Scope:', scope, 'Working directory:', directory);
 
       createSkill(skillName, { ...config, source: skillSource }, directory, scope);
-      res.json(buildDeferredRestartResponse(
-        `Skill ${skillName} created successfully. Restart OpenCode to apply.`,
+      res.json(buildAppliedResponse(
+        `Skill ${skillName} created successfully.`,
       ));
     } catch (error) {
       console.error('Failed to create skill:', error);
@@ -625,14 +627,11 @@ export const registerSkillRoutes = (app, dependencies) => {
         console.log(`[Server] Renaming skill: ${skillName} -> ${newName}`);
         console.log('[Server] Working directory:', directory);
         renameSkill(skillName, newName, directory);
-        await refreshOpenCodeAfterConfigChange('skill rename');
-
+        // OpenCode 2 watches the skills directories: the renamed folder is
+        // picked up like any other write, no restart and no client reload.
         return res.json({
-          success: true,
+          ...buildAppliedResponse(`Skill renamed to ${newName} successfully.`),
           name: newName,
-          requiresReload: true,
-          message: `Skill renamed to ${newName} successfully. Reloading interface…`,
-          reloadDelayMs: clientReloadDelayMs,
         });
       }
 
@@ -640,8 +639,8 @@ export const registerSkillRoutes = (app, dependencies) => {
       console.log('[Server] Working directory:', directory);
 
       updateSkill(skillName, updates, directory, updates?.targetPath);
-      res.json(buildDeferredRestartResponse(
-        `Skill ${skillName} updated successfully. Restart OpenCode to apply.`,
+      res.json(buildAppliedResponse(
+        `Skill ${skillName} updated successfully.`,
       ));
     } catch (error) {
       console.error('[Server] Failed to update skill:', error);
@@ -727,8 +726,8 @@ export const registerSkillRoutes = (app, dependencies) => {
       }
 
       deleteSkill(skillName, directory);
-      res.json(buildDeferredRestartResponse(
-        `Skill ${skillName} deleted successfully. Restart OpenCode to apply.`,
+      res.json(buildAppliedResponse(
+        `Skill ${skillName} deleted successfully.`,
       ));
     } catch (error) {
       console.error('Failed to delete skill:', error);