@vantran-se/openchamber-web 2.0.4 → 2.0.5

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

@@ -125,9 +125,12 @@ export const registerSkillRoutes = (app, dependencies) => {
     return { scope: SKILL_SCOPE.USER, source };
   };
 
+  // Returns null when OpenCode's list could not be read (not running, error,
+  // timeout, malformed payload) so callers can tell a failed fetch from a
+  // genuinely empty list.
   const fetchOpenCodeDiscoveredSkills = async (workingDirectory) => {
     if (!getOpenCodePort()) {
-      return [];
+      return null;
     }
 
     try {
@@ -145,13 +148,19 @@ export const registerSkillRoutes = (app, dependencies) => {
       const response = await client.skill.list();
       const payload = response?.data;
       if (!Array.isArray(payload)) {
-        return [];
+        return null;
       }
 
       return payload
         .map((item) => {
           const name = typeof item?.name === 'string' ? item.name.trim() : '';
-          const location = typeof item?.location === 'string' ? item.location : '';
+          // OpenCode v1's skill payload used `location`; v2 renamed the field
+          // to `path`. Accept both, or the whole authoritative list is dropped
+          // and the panel falls back to the (smaller) local disk scan.
+          const rawLocation = typeof item?.path === 'string' ? item.path : (typeof item?.location === 'string' ? item.location : '');
+          // v1 marked built-in skills with `<built-in>`; v2 gives them a synthetic
+          // `/builtin/<id>.md` path. Normalize so they stay read-only in the panel.
+          const location = rawLocation.startsWith('/builtin/') ? '<built-in>' : rawLocation;
           const description = typeof item?.description === 'string' ? item.description : '';
           const content = typeof item?.content === 'string' ? item.content : '';
           if (!name || !location) {
@@ -183,7 +192,7 @@ export const registerSkillRoutes = (app, dependencies) => {
         .filter(Boolean);
     } catch (error) {
       console.error('Failed to list OpenCode skills:', error);
-      return [];
+      return null;
     }
   };
 
@@ -244,7 +253,7 @@ export const registerSkillRoutes = (app, dependencies) => {
       }
       const openCodeSkills = await fetchOpenCodeDiscoveredSkills(directory);
       const localSkills = discoverSkills(directory);
-      const skills = mergeDiscoveredSkills(openCodeSkills, localSkills);
+      const skills = mergeDiscoveredSkills(openCodeSkills ?? [], localSkills);
 
       const enrichedSkills = skills.map((skill) => {
         const sources = getSkillSources(skill.name, directory, skill);
@@ -268,7 +277,7 @@ export const registerSkillRoutes = (app, dependencies) => {
       // OpenCode's own skill-list endpoint is not usable for this: on 1.18.14
       // it returns only global and builtin skills, omitting the project
       // `.agents`/`.claude` skills the agent demonstrably has.
-      res.json({
+      const body = {
         skills: enrichedSkills,
         externalSkills: {
           // `OPENCODE_DISABLE_CLAUDE_CODE` is the broad switch; the specific
@@ -277,7 +286,14 @@ export const registerSkillRoutes = (app, dependencies) => {
             || isEnvFlagEnabled(process.env.OPENCODE_DISABLE_CLAUDE_CODE_SKILLS),
           allDisabled: isEnvFlagEnabled(process.env.OPENCODE_DISABLE_EXTERNAL_SKILLS),
         },
-      });
+      };
+      // The list is only the disk scan when OpenCode's own list failed:
+      // built-in skills and anything OpenCode finds only through its config
+      // are missing, so the client must not treat this as complete.
+      if (openCodeSkills === null) {
+        body.openCodeSkillsUnavailable = true;
+      }
+      res.json(body);
     } catch (error) {
       console.error('Failed to list skills:', error);
       res.status(500).json({ error: 'Failed to list skills' });
@@ -366,7 +382,7 @@ export const registerSkillRoutes = (app, dependencies) => {
       }
 
       const resolvedDiscovered = mergeDiscoveredSkills(
-        await fetchOpenCodeDiscoveredSkills(directory),
+        (await fetchOpenCodeDiscoveredSkills(directory)) ?? [],
         discoverSkills(directory),
       );
       const installedByName = new Map(resolvedDiscovered.map((s) => [s.name, s]));
@@ -538,7 +554,7 @@ export const registerSkillRoutes = (app, dependencies) => {
       if (error) {
         return res.status(400).json({ error });
       }
-      const discoveredSkill = (await fetchOpenCodeDiscoveredSkills(directory))
+      const discoveredSkill = ((await fetchOpenCodeDiscoveredSkills(directory)) ?? [])
         .find((skill) => skill.name === skillName) || null;
       const sources = getSkillSources(skillName, directory, discoveredSkill);
 
@@ -567,7 +583,7 @@ export const registerSkillRoutes = (app, dependencies) => {
         return res.status(400).json({ error });
       }
 
-      const discoveredSkill = (await fetchOpenCodeDiscoveredSkills(directory))
+      const discoveredSkill = ((await fetchOpenCodeDiscoveredSkills(directory)) ?? [])
         .find((skill) => skill.name === skillName) || null;
       const sources = getSkillSources(skillName, directory, discoveredSkill);
       if (!sources.md.exists || !sources.md.dir) {
@@ -661,7 +677,7 @@ export const registerSkillRoutes = (app, dependencies) => {
         return res.status(400).json({ error });
       }
 
-      const discoveredSkill = (await fetchOpenCodeDiscoveredSkills(directory))
+      const discoveredSkill = ((await fetchOpenCodeDiscoveredSkills(directory)) ?? [])
         .find((skill) => skill.name === skillName) || null;
       const sources = getSkillSources(skillName, directory, discoveredSkill);
       if (!sources.md.exists || !sources.md.dir) {
@@ -695,7 +711,7 @@ export const registerSkillRoutes = (app, dependencies) => {
         return res.status(400).json({ error });
       }
 
-      const discoveredSkill = (await fetchOpenCodeDiscoveredSkills(directory))
+      const discoveredSkill = ((await fetchOpenCodeDiscoveredSkills(directory)) ?? [])
         .find((skill) => skill.name === skillName) || null;
       const sources = getSkillSources(skillName, directory, discoveredSkill);
       if (!sources.md.exists || !sources.md.dir) {

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

@@ -28,7 +28,7 @@ const createTempProject = () => {
   return projectRoot;
 };
 
-const startSkillsApp = ({ projectRoot }) => {
+const startSkillsApp = ({ projectRoot, overrides = {} }) => {
   const app = express();
   app.use(express.json());
 
@@ -76,6 +76,7 @@ const startSkillsApp = ({ projectRoot }) => {
     fetchGitHubRepoMetas: async () => ({}),
     getProfiles: () => [],
     getProfile: () => null,
+    ...overrides,
   });
 
   const server = app.listen(0);
@@ -213,4 +214,123 @@ describe('skill-routes directory soft fallback', () => {
       });
     }
   });
+
+  it('lists OpenCode skills reported with the v2 `path` field and keeps the v1 `location` fallback', async () => {
+    projectRoot = createTempProject();
+
+    // OpenCode v2's skill payload renamed `location` to `path`. The route maps
+    // the fetch result to { name, path, ... }; with the old field only, the
+    // whole authoritative list was dropped and the panel fell back to the
+    // smaller local disk scan. Serve a v2-style payload from a stub.
+    const stub = express();
+    stub.get('/api/skill', (_req, res) => {
+      res.json({
+        location: { directory: projectRoot },
+        data: [
+          {
+            id: 'v2-path-skill',
+            name: 'v2-path-skill',
+            path: path.join(projectRoot, '.agents', 'skills', 'v2-path-skill'),
+            description: 'Delivered with the v2 path field',
+          },
+          {
+            id: 'v1-location-skill',
+            name: 'v1-location-skill',
+            location: path.join(projectRoot, '.agents', 'skills', 'v1-location-skill'),
+            description: 'Delivered with the legacy location field',
+          },
+          {
+            id: 'opencode',
+            name: 'OpenCode',
+            path: '/builtin/opencode.md',
+            description: 'v2 built-in skill with a synthetic path',
+          },
+          {
+            id: 'unlocated-skill',
+            name: 'unlocated-skill',
+            description: 'Has neither field; must be dropped',
+          },
+        ],
+      });
+    });
+    const stubServer = await new Promise((resolve) => {
+      const server = stub.listen(0, () => resolve(server));
+    });
+    const stubPort = stubServer.address().port;
+
+    try {
+      appHandle = startSkillsApp({
+        projectRoot,
+        overrides: {
+          buildOpenCodeUrl: () => `http://127.0.0.1:${stubPort}/`,
+          getOpenCodePort: () => stubPort,
+          getOpenCodeAuthHeaders: () => ({}),
+        },
+      });
+
+      const listResponse = await fetch(
+        `${appHandle.baseUrl}/api/config/skills?directory=${encodeURIComponent(projectRoot)}`,
+      );
+      expect(listResponse.status).toBe(200);
+      const payload = await listResponse.json();
+      const byName = new Map(payload.skills.map((skill) => [skill.name, skill]));
+
+      expect(byName.has('v2-path-skill')).toBe(true);
+      expect(byName.get('v2-path-skill').path).toContain('v2-path-skill');
+
+      expect(byName.has('v1-location-skill')).toBe(true);
+      expect(byName.get('v1-location-skill').path).toContain('v1-location-skill');
+
+      expect(byName.get('OpenCode')?.path).toBe('<built-in>');
+      expect(byName.get('OpenCode')?.renamable).toBe(false);
+
+      expect(byName.has('unlocated-skill')).toBe(false);
+    } finally {
+      stubServer.close();
+    }
+  });
+  it('flags the list as partial when OpenCode skill list fails, and not when it succeeds', async () => {
+    projectRoot = createTempProject();
+    fs.mkdirSync(path.join(projectRoot, '.agents', 'skills', 'disk-skill'), { recursive: true });
+    fs.writeFileSync(
+      path.join(projectRoot, '.agents', 'skills', 'disk-skill', 'SKILL.md'),
+      '---\nname: disk-skill\ndescription: On disk\n---\nBody\n',
+    );
+
+    let failing = true;
+    const stub = express();
+    stub.get('/api/skill', (_req, res) => {
+      if (failing) {
+        res.status(500).json({ error: 'boom' });
+        return;
+      }
+      res.json({ data: [] });
+    });
+    const stubServer = await new Promise((resolve) => {
+      const server = stub.listen(0, () => resolve(server));
+    });
+    const stubPort = stubServer.address().port;
+
+    try {
+      appHandle = startSkillsApp({
+        projectRoot,
+        overrides: {
+          buildOpenCodeUrl: () => `http://127.0.0.1:${stubPort}/`,
+          getOpenCodePort: () => stubPort,
+        },
+      });
+      const url = `${appHandle.baseUrl}/api/config/skills?directory=${encodeURIComponent(projectRoot)}`;
+
+      const failed = await (await fetch(url)).json();
+      expect(failed.openCodeSkillsUnavailable).toBe(true);
+      expect(failed.skills.map((skill) => skill.name)).toContain('disk-skill');
+
+      failing = false;
+      const complete = await (await fetch(url)).json();
+      expect(complete.openCodeSkillsUnavailable).toBeUndefined();
+      expect(complete.skills.map((skill) => skill.name)).toContain('disk-skill');
+    } finally {
+      stubServer.close();
+    }
+  });
 });

package/server/lib/opencode/upgrade-capability.js

@@ -1,23 +1,9 @@
-// TEMPORARY WORKAROUND — Windows ARM64: native opencode.exe fails with a Bun
-// FFI/TinyCC dlopen error (https://github.com/anomalyco/opencode/issues/19130).
-// Disable OpenCode self-upgrade on ARM64 so it can't overwrite the working x64
-// binary with the broken ARM64 build. Remove when the upstream issue is resolved.
-const isWindowsArm64 = () => process.platform === 'win32' && process.arch === 'arm64';
-
 export const resolveOpenCodeUpgradeCapability = ({
   isExternal,
   hasManagedProcess,
   activeBinary,
   isBundledBinary,
 }) => {
-  if (isWindowsArm64()) {
-    return {
-      supported: false,
-      manager: 'openchamber',
-      reason: 'windows-arm64-workaround',
-    };
-  }
-
   if (isExternal) {
     return {
       supported: false,

package/server/lib/opencode/v1-migration-topup.js

@@ -21,14 +21,16 @@
  *    seen v2 activity. Every visited session gets its `session_message` rows
  *    deleted and replaced by the V1 transform, so a migrated session that was
  *    continued in v2 would lose that conversation.
- * 3. A session deleted in v2 comes back. A v2 delete removes the `session_v2`
- *    row but leaves the legacy `session` row behind, so the loop imports it
- *    again. Decided by the maintainer (2026-09-22): people run 1.x and 2.x
- *    side by side while switching, and OpenChamber's own time-based cleanup
- *    may have deleted sessions the user never touched, so importing again is
- *    better than importing nothing. Deleting again is cheap; a lost 1.x
- *    session is not. This holds until OpenCode ships an import route that
- *    takes an explicit list of sessions.
+ * 3. Only 1.x activity since the last completed import triggers a new one.
+ *    A v2 delete removes the `session_v2` row but leaves the legacy `session`
+ *    row behind, so "missing from v2" alone would bring deleted sessions back
+ *    on every start. A legacy session counts as missing only when its
+ *    `time_updated` is newer than the completion stamp OpenCode writes on
+ *    `migration.v1-v2`: only OpenCode 1.x writes that table, so an unchanged
+ *    table means nobody ran 1.x since and the top-up skips. Decided by the
+ *    maintainer (2026-09-24). When 1.x was used again, OpenCode still walks
+ *    every id below the cursor, so a deleted session sorting below a fresh one
+ *    comes back with it; that needs an import route taking an explicit list.
  *
  * The loop OpenCode runs is `SELECT id FROM session WHERE id < cursor ORDER BY
  * id DESC LIMIT 1`, one session at a time, so the cursor has to be strictly
@@ -196,11 +198,15 @@ const findRevisitedSessionsWithV2Activity = (db, cursor, completedAt) =>
       return parsed.success ? [parsed.data.id] : [];
     });
 
-/** A legacy session with no `session_v2` twin, whether never imported or deleted in v2 (see rule 3). */
-const MISSING_CONDITION = 'id NOT IN (SELECT id FROM session_v2)';
+/**
+ * A legacy session with no `session_v2` twin that 1.x touched after the last
+ * completed import (see rule 3). Bound parameter: the completion timestamp.
+ */
+const MISSING_CONDITION = 'id NOT IN (SELECT id FROM session_v2) AND time_updated > ?';
 
-const countMissingSessions = (db) =>
-  firstRow(countRowSchema, db.all(`SELECT COUNT(*) AS value FROM session WHERE ${MISSING_CONDITION}`))?.value ?? 0;
+const countMissingSessions = (db, completedAt) =>
+  firstRow(countRowSchema, db.all(`SELECT COUNT(*) AS value FROM session WHERE ${MISSING_CONDITION}`, [completedAt]))
+    ?.value ?? 0;
 
 const countRevisitedSessions = (db, cursor) =>
   firstRow(
@@ -244,12 +250,12 @@ export const topUpV1Migration = (options = {}) => {
     const migration = readCompletedMigration(db);
     if (!migration) return outcome('skipped', 'migration-not-completed');
 
-    const missingCount = countMissingSessions(db);
+    const missingCount = countMissingSessions(db, migration.completedAt);
     if (missingCount === 0) return outcome('skipped', 'nothing-missing');
 
     const maxMissing = firstRow(
       nullableIdRowSchema,
-      db.all(`SELECT MAX(id) AS id FROM session WHERE ${MISSING_CONDITION}`),
+      db.all(`SELECT MAX(id) AS id FROM session WHERE ${MISSING_CONDITION}`, [migration.completedAt]),
     )?.id;
     if (!maxMissing) return outcome('skipped', 'nothing-missing');
 
@@ -271,7 +277,7 @@ export const topUpV1Migration = (options = {}) => {
       MIGRATION_STATE_KEY,
     ]);
     logger.log(
-      `[OpenCode] Scheduled the import of ${missingCount} OpenCode 1.x session(s) created after the v2 migration; ` +
+      `[OpenCode] Scheduled the import of ${missingCount} OpenCode 1.x session(s) changed since the last v2 import; ` +
         `OpenCode will re-import ${revisitedCount} untouched session(s) on the way.`,
     );
     return outcome('scheduled', undefined, missingCount, revisitedCount);

package/server/lib/opencode/v1-migration-topup.test.js

@@ -226,13 +226,21 @@ describe.skipIf(!sqlite)('topUpV1Migration', () => {
     });
   });
 
-  it('imports a session deleted in v2 again rather than leaving newer 1.x sessions behind', () => {
-    // ses_a was walked by the migration and deleted in v2 (only the legacy row
-    // is left); ses_d was created after. The maintainer chose to bring ses_a
-    // back over losing ses_d: deleting again is cheap, a lost session is not.
+  it('does not bring back a session deleted in v2 when 1.x was not used since', () => {
+    // ses_a was imported and then deleted in v2: only its legacy row is left,
+    // untouched since the last completed import.
     createDatabase();
-    seed({ v1: [{ id: 'ses_a', timeCreated: COMPLETED_AT - 1 }, 'ses_d'] });
-    expect(run()).toEqual({ status: 'scheduled', missing: 2, revisited: 0 });
+    seed({ v1: [{ id: 'ses_a', timeCreated: COMPLETED_AT - 1 }] });
+    expect(run()).toEqual({ status: 'skipped', missing: 0, revisited: 0, reason: 'nothing-missing' });
+    expect(readMigrationRow().state).toEqual({ phase: 'completed' });
+  });
+
+  it('imports only sessions 1.x changed since the last import, cursor included', () => {
+    // ses_z (deleted in v2, old) sorts above ses_d (fresh from 1.x): the
+    // cursor must stop at ses_d so ses_z stays gone.
+    createDatabase();
+    seed({ v1: [{ id: 'ses_z', timeCreated: COMPLETED_AT - 1 }, 'ses_d'] });
+    expect(run()).toEqual({ status: 'scheduled', missing: 1, revisited: 0 });
     expect(readMigrationRow().state).toEqual({ phase: 'sessions', cursor: computeResumeCursor('ses_d') });
   });
 

package/server/lib/opencode/v2-install.d.ts

@@ -4,5 +4,6 @@ export function installOpenCodeV2(options?: {
   env?: NodeJS.ProcessEnv;
   fetchImpl?: typeof fetch;
   platform?: NodeJS.Platform;
+  arch?: NodeJS.Architecture;
   tarCommand?: string;
 }): Promise<string>;

package/server/lib/opencode/v2-install.js

@@ -18,10 +18,10 @@ const packageDistSchema = z.object({
 });
 
 // OpenCode's installer is a bash script, so Windows installs the npm platform
-// package that script downloads. x64-baseline serves arm64 too: the native arm64
-// build fails to load (https://github.com/anomalyco/opencode/issues/19130), the
-// same workaround the desktop bundle uses in packages/electron/scripts/prepare-opencode-cli.mjs.
-const WINDOWS_PACKAGE = '@opencode/cli-windows-x64-baseline';
+// package that script downloads, the same one the desktop bundle picks in
+// packages/electron/scripts/prepare-opencode-cli.mjs. x64 takes the baseline
+// build so hosts without AVX2 still run it.
+const windowsPackage = (arch) => (arch === 'arm64' ? '@opencode/cli-windows-arm64' : '@opencode/cli-windows-x64-baseline');
 
 export const supportsOpenCodeV2Install = (platform = process.platform) =>
   (platform === 'darwin' || platform === 'linux' || platform === 'win32') && (process.arch === 'x64' || process.arch === 'arm64');
@@ -72,8 +72,8 @@ const prepareInstallerScript = async ({ version, workDirectory, env, fetchImpl }
  * Downloads the Windows platform package, checks it against the integrity npm
  * publishes for it, and unpacks it. Returns the step that replaces the binary.
  */
-const prepareWindowsBinary = async ({ version, directory, workDirectory, fetchImpl, tarCommand }) => {
-  const metadataResponse = await fetchImpl(`${NPM_REGISTRY}/${WINDOWS_PACKAGE.replace('/', '%2F')}/${version}`, { signal: AbortSignal.timeout(15_000) });
+const prepareWindowsBinary = async ({ version, arch, directory, workDirectory, fetchImpl, tarCommand }) => {
+  const metadataResponse = await fetchImpl(`${NPM_REGISTRY}/${windowsPackage(arch).replace('/', '%2F')}/${version}`, { signal: AbortSignal.timeout(15_000) });
   if (!metadataResponse.ok) throw new Error('Could not resolve the OpenCode v2 package.');
   const { dist } = packageDistSchema.parse(await metadataResponse.json());
   if (new URL(dist.tarball).origin !== NPM_REGISTRY) throw new Error('The OpenCode v2 package is not served by the npm registry.');
@@ -100,6 +100,7 @@ export const installOpenCodeV2 = async ({
   env = process.env,
   fetchImpl = fetch,
   platform = process.platform,
+  arch = process.arch,
   // Windows' own bsdtar. Git Bash's GNU tar on PATH reads `C:\...` as a remote host.
   tarCommand = path.join(process.env.SystemRoot || 'C:\\Windows', 'System32', 'tar.exe'),
 } = {}) => {
@@ -119,7 +120,7 @@ export const installOpenCodeV2 = async ({
     if (!releaseResponse.ok) throw new Error('Could not resolve the OpenCode v2 release.');
     const { version } = releaseSchema.parse(await releaseResponse.json());
     const replaceBinary = windows
-      ? await prepareWindowsBinary({ version, directory, workDirectory: lock, fetchImpl, tarCommand })
+      ? await prepareWindowsBinary({ version, arch, directory, workDirectory: lock, fetchImpl, tarCommand })
       : await prepareInstallerScript({ version, workDirectory: lock, env, fetchImpl });
     for (const name of binaryNames) {
       const target = path.join(directory, name);

package/server/lib/opencode/v2-install.test.js

@@ -63,7 +63,7 @@ chmod 755 ${quote(binary)}
   });
 
   describe('on Windows', () => {
-    const TARBALL = 'https://registry.npmjs.org/@opencode/cli-windows-x64-baseline/-/cli-windows-x64-baseline-2.0.15.tgz';
+    const tarballOf = (name) => `https://registry.npmjs.org/@opencode/${name}/-/${name}-2.0.15.tgz`;
     let exe;
     const integrityOf = (bytes) => `sha512-${createHash('sha512').update(bytes).digest('base64')}`;
     // The platform package keeps its binary at package/bin/opencode.exe. Here it is a
@@ -77,14 +77,17 @@ chmod 755 ${quote(binary)}
       await fs.rm(root, { recursive: true, force: true });
       return bytes;
     };
-    const runWindows = (archive, integrity = integrityOf(archive)) => installOpenCodeV2({
+    const PACKAGE_BY_ARCH = { x64: 'cli-windows-x64-baseline', arm64: 'cli-windows-arm64' };
+    const runWindows = (archive, integrity = integrityOf(archive), arch = 'x64') => installOpenCodeV2({
       homeDirectory,
       platform: 'win32',
+      arch,
       tarCommand: 'tar',
       fetchImpl: async (url) => {
+        const name = PACKAGE_BY_ARCH[arch];
         if (url.endsWith('/@opencode%2Fcli/latest')) return Response.json({ version: '2.0.15' });
-        if (url.endsWith('/@opencode%2Fcli-windows-x64-baseline/2.0.15')) return Response.json({ dist: { tarball: TARBALL, integrity } });
-        if (url === TARBALL) return new Response(archive);
+        if (url.endsWith(`/@opencode%2F${name}/2.0.15`)) return Response.json({ dist: { tarball: tarballOf(name), integrity } });
+        if (url === tarballOf(name)) return new Response(archive);
         return new Response(null, { status: 404 });
       },
     });
@@ -101,6 +104,12 @@ chmod 755 ${quote(binary)}
       await expect(fs.stat(path.join(path.dirname(exe), '.openchamber-install'))).rejects.toMatchObject({ code: 'ENOENT' });
     });
 
+    it('installs the native arm64 package on Windows ARM64', async () => {
+      const archive = await pack('2.0.15');
+      expect(await runWindows(archive, integrityOf(archive), 'arm64')).toBe(exe);
+      expect(await readOpenCodeCliVersion({ binary: exe, args: [] })).toBe('2.0.15');
+    });
+
     it('rejects a package that does not match its published integrity before touching the binary', async () => {
       const archive = await pack('2.0.15');
       await expect(runWindows(archive, integrityOf(Buffer.from('other')))).rejects.toThrow('integrity');

package/server/lib/opencode/watcher.js

@@ -47,13 +47,15 @@ export const createOpenCodeWatcherRuntime = (deps) => {
     const signal = abortController.signal;
 
     if (globalEventHub) {
+      // The events of isolated spaces feed this watcher too, so live status, unread marks and
+      // notifications work for a space's sessions as for the host's.
       unsubscribeEvent = globalEventHub.subscribeEvent((event) => {
         const payload = unwrapGlobalEventPayload(event.payload);
         if (!payload || typeof payload !== 'object') {
           return;
         }
         emitTranslated(payload);
-      });
+      }, { spaces: true });
       unsubscribeStatus = globalEventHub.subscribeStatus((status) => {
         if (signal.aborted) {
           return;

package/server/lib/opencode/websearch-config.js

@@ -9,7 +9,7 @@ import {
   readConfigLayers,
   writeConfig,
 } from './shared.js';
-import { findWebSearchProjectOverride, writeWebSearchSelection } from './config-v2.js';
+import { findWebSearchProjectOverride, writeWarmingEnabled, writeWebSearchSelection } from './config-v2.js';
 
 /**
  * Writes the `websearch` choice into the config OpenCode reads last among the
@@ -26,6 +26,18 @@ export function setWebSearchSelection(selection) {
   return { path: target.path, changed };
 }
 
+/**
+ * Turns session warming on or off in the same file the web search choice goes
+ * to; OpenCode watches it, so the change applies without a restart.
+ */
+export function setWarmingEnabled(enabled) {
+  const layers = readConfigLayers(null);
+  const target = getJsonWriteTarget(layers, AGENT_SCOPE.USER);
+  const changed = writeWarmingEnabled(target.config, enabled);
+  if (changed) writeConfig(target.config, target.path);
+  return { path: target.path, changed };
+}
+
 /**
  * Where the effective `websearch` value for `directory` comes from, as far as
  * a Settings write is concerned: `projectPath` is the project config that

package/server/lib/quota/providers/kimi.js

@@ -12,7 +12,7 @@ import {
 
 export const providerId = 'kimi-for-coding';
 export const providerName = 'Kimi for Coding';
-const aliases = ['kimi-for-coding', 'kimi'];
+const aliases = ['kimi-for-coding', 'kimi', 'kimi-code-plan-global'];
 
 // Kimi's weekly `usage` block reports `used`; its rate-limit `limits[].detail`
 // blocks report `remaining` instead. Neither field is guaranteed present, so

package/server/lib/realtime-proxy.js

@@ -10,10 +10,14 @@ const isAllowedSsePath = (pathname) => {
     || pathname === '/api/notifications/stream';
 };
 
+// The same three sockets of an isolated space, under `/api/spaces/<id>/`, matched by shape.
+const SPACE_WS_PATH = /^\/api\/spaces\/[0-9a-f]{12}\/(?:terminal\/ws|event\/ws|global\/event\/ws)$/;
+
 const isAllowedWebSocketPath = (pathname) => {
   return pathname === '/api/event/ws'
     || pathname === '/api/global/event/ws'
-    || pathname === '/api/terminal/ws';
+    || pathname === '/api/terminal/ws'
+    || SPACE_WS_PATH.test(pathname);
 };
 
 const normalizeBaseUrl = (value) => {

package/server/lib/realtime-proxy.test.js

@@ -228,6 +228,35 @@ describe('realtime proxy', () => {
     }
   });
 
+  it('proxies the sockets of an isolated space by path shape, and refuses another path under the prefix', async () => {
+    const seen = [];
+    const upstreamServer = http.createServer();
+    const upstreamWs = new WebSocketServer({ server: upstreamServer });
+    upstreamWs.on('connection', (socket, request) => {
+      seen.push(request.url);
+      socket.send('ready');
+    });
+    const upstreamOrigin = await listen(upstreamServer);
+    const { origin, runtime } = await startProxyServer({ apiBaseUrl: upstreamOrigin });
+    const attempt = (path) => new Promise((resolve, reject) => {
+      const client = new WebSocket(buildRealtimeProxyWsUrl(origin, `${upstreamOrigin.replace(/^http:/, 'ws:')}${path}`), { headers: { Origin: 'openchamber-ui://app' } });
+      client.once('message', (data) => { client.close(); resolve({ message: data.toString() }); });
+      client.once('close', (code) => resolve({ code }));
+      client.once('error', reject);
+    });
+
+    try {
+      expect(await attempt('/api/spaces/a1b2c3d4e5f6/terminal/ws')).toEqual({ message: 'ready' });
+      expect(await attempt('/api/spaces/a1b2c3d4e5f6/event/ws?directory=%2Fspaces%2Fa1b2c3d4e5f6%2Frepo')).toEqual({ message: 'ready' });
+      expect(await attempt('/api/spaces/a1b2c3d4e5f6/dictation/ws')).toEqual({ code: 1008 });
+      expect(await attempt('/api/spaces/A1B2C3D4E5F6/terminal/ws')).toEqual({ code: 1008 });
+      expect(seen).toEqual(['/api/spaces/a1b2c3d4e5f6/terminal/ws', '/api/spaces/a1b2c3d4e5f6/event/ws?directory=%2Fspaces%2Fa1b2c3d4e5f6%2Frepo']);
+      upstreamWs.close();
+    } finally {
+      runtime.stop();
+    }
+  });
+
   it('allows first passwordless WebSocket proxy upgrade without an existing cookie', async () => {
     const upstreamServer = http.createServer();
     const upstreamWs = new WebSocketServer({ server: upstreamServer });

package/server/lib/relay/tunnel-host.js

@@ -37,7 +37,10 @@ const ALLOWED_WS_PATHS = new Set([
 // Extension surfaces carry the extension id in the path, so they are matched
 // by shape rather than listed.
 const GUEST_SURFACE_WS_PATH = /^\/api\/guests\/[a-z][a-z0-9-]*\/surface\/ws$/;
-export const isAllowedRelayWebSocketPath = (pathname) => ALLOWED_WS_PATHS.has(pathname) || GUEST_SURFACE_WS_PATH.test(pathname);
+// The sockets of an isolated space carry the space id in the path: the same four sockets,
+// under `/api/spaces/<id>/`, matched by shape.
+const SPACE_WS_PATH = /^\/api\/spaces\/[0-9a-f]{12}\/(?:terminal\/ws|dev-tunnel|event\/ws|global\/event\/ws)$/;
+export const isAllowedRelayWebSocketPath = (pathname) => ALLOWED_WS_PATHS.has(pathname) || GUEST_SURFACE_WS_PATH.test(pathname) || SPACE_WS_PATH.test(pathname);
 
 // Hop-by-hop headers stripped from tunneled requests; `host` is set by fetch
 // to the loopback origin. content-length is dropped too because the body is

package/server/lib/relay/tunnel-host.test.js

@@ -153,6 +153,17 @@ describe('relay host WebSocket allowlist', () => {
     expect(isAllowedRelayWebSocketPath('/api/database/ws')).toBe(false);
   });
 
+  test('allows the sockets of an isolated space by path shape only', () => {
+    for (const socket of ['terminal/ws', 'dev-tunnel', 'event/ws', 'global/event/ws']) {
+      expect(isAllowedRelayWebSocketPath(`/api/spaces/a1b2c3d4e5f6/${socket}`)).toBe(true);
+    }
+    expect(isAllowedRelayWebSocketPath('/api/spaces/a1b2c3d4e5f6/dictation/ws')).toBe(false);
+    expect(isAllowedRelayWebSocketPath('/api/spaces/A1B2C3D4E5F6/terminal/ws')).toBe(false);
+    expect(isAllowedRelayWebSocketPath('/api/spaces/a1b2c3d4e5f/terminal/ws')).toBe(false);
+    expect(isAllowedRelayWebSocketPath('/api/spaces/a1b2c3d4e5f6/terminal/ws/x')).toBe(false);
+    expect(isAllowedRelayWebSocketPath('/api/spaces//terminal/ws')).toBe(false);
+  });
+
   test('allows an extension surface socket by path shape only', () => {
     expect(isAllowedRelayWebSocketPath('/api/guests/server-chrome/surface/ws')).toBe(true);
     expect(isAllowedRelayWebSocketPath('/api/guests/Server/surface/ws')).toBe(false);