@openchambery/web 2.0.0-beta.3 → 2.0.0-beta.5

package/server/lib/notifications/template-runtime.js

@@ -1,5 +1,75 @@
+import { projectSessionMessageRecords } from '../session-turn-pages/session-message-projection.js';
 import { summarizeText as summarizeSharedText } from '../text/summarization.js';
 
+const trimmedText = (value) => (typeof value === 'string' && value.trim() ? value.trim() : '');
+
+const isSessionRecord = (value) => {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  return typeof value.id === 'string'
+    || typeof value.sessionID === 'string'
+    || typeof value.title === 'string'
+    || typeof value.parentID === 'string'
+    || (value.metadata && typeof value.metadata === 'object');
+};
+
+/**
+ * OpenCode 2 `GET /api/session/:id` returns `{ data: Session }`.
+ * Legacy responses and tests still return the session object itself.
+ * @param {unknown} payload
+ * @returns {object | null}
+ */
+export const readNotificationSessionRecord = (payload) => {
+  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) return null;
+  if (isSessionRecord(payload.data)) return payload.data;
+  return isSessionRecord(payload) ? payload : null;
+};
+
+const TITLE_EVENT_TYPES = new Set(['session.created', 'session.updated', 'session.renamed']);
+
+/**
+ * Title carried by a session lifecycle event.
+ * v2 puts it on `data.title` (`session.created` / `session.renamed`).
+ * Legacy events put it on `properties.info.title`.
+ * @param {object | null | undefined} payload
+ * @returns {{ sessionId: string, title: string } | null}
+ */
+export const readSessionTitleFromEvent = (payload) => {
+  if (!payload || typeof payload !== 'object' || !TITLE_EVENT_TYPES.has(payload.type)) return null;
+  const bodies = [payload.properties, payload.data].filter((body) => body && typeof body === 'object' && !Array.isArray(body));
+  for (const body of bodies) {
+    const info = body.info && typeof body.info === 'object' ? body.info : null;
+    const title = trimmedText(info?.title) || trimmedText(body.title);
+    const sessionId = trimmedText(info?.id)
+      || trimmedText(info?.sessionID)
+      || trimmedText(body.sessionID)
+      || trimmedText(body.id);
+    if (title && sessionId) return { sessionId, title };
+  }
+  return null;
+};
+
+const readNotificationDirectory = (payload) => {
+  const properties = payload?.properties && typeof payload.properties === 'object' ? payload.properties : {};
+  const data = payload?.data && typeof payload.data === 'object' && !Array.isArray(payload.data) ? payload.data : {};
+  const info = properties.info && typeof properties.info === 'object' ? properties.info : {};
+  const dataInfo = data.info && typeof data.info === 'object' ? data.info : {};
+  const candidates = [
+    properties.directory,
+    info.directory,
+    info.location?.directory,
+    payload?.location?.directory,
+    data.directory,
+    data.location?.directory,
+    dataInfo.directory,
+    dataInfo.location?.directory,
+  ];
+  for (const value of candidates) {
+    const directory = trimmedText(value);
+    if (directory) return directory;
+  }
+  return '';
+};
+
 export const createNotificationTemplateRuntime = (deps) => {
   const {
     readSettingsFromDisk,
@@ -133,37 +203,45 @@ export const createNotificationTemplateRuntime = (deps) => {
     return '';
   };
 
-  const fetchLastAssistantMessageText = async (sessionId, messageId, maxLength = NOTIFICATION_BODY_MAX_CHARS) => {
+  const fetchLastAssistantMessageText = async (sessionId, messageId, maxLength = NOTIFICATION_BODY_MAX_CHARS, directory) => {
     if (!sessionId) return '';
 
     try {
-      const url = buildOpenCodeUrl(`/session/${encodeURIComponent(sessionId)}/message`, '');
-      const response = await fetch(`${url}?limit=5`, {
+      const base = buildOpenCodeUrl(`/session/${encodeURIComponent(sessionId)}/message`, '');
+      const params = new URLSearchParams({ limit: '5', order: 'desc' });
+      const scopedDirectory = trimmedText(directory);
+      if (scopedDirectory) params.set('directory', scopedDirectory);
+      const response = await fetch(`${base}?${params.toString()}`, {
         method: 'GET',
         headers: {
           Accept: 'application/json',
-          ...getOpenCodeAuthHeaders(),
+          ...(typeof getOpenCodeAuthHeaders === 'function' ? getOpenCodeAuthHeaders() : {}),
         },
         signal: AbortSignal.timeout(3000),
       });
 
       if (!response.ok) return '';
 
-      const messages = await response.json().catch(() => null);
-      if (!Array.isArray(messages)) return '';
+      const payload = await response.json().catch(() => null);
+      // Legacy lists are a chronological array. OpenCode 2 returns `{ data }`
+      // and `order=desc` puts the newest turn first.
+      const newestFirst = !Array.isArray(payload);
+      const records = Array.isArray(payload)
+        ? payload
+        : (Array.isArray(payload?.data) ? payload.data : null);
+      if (!records) return '';
+      const projected = projectSessionMessageRecords(records);
+      const messages = newestFirst ? projected : [...projected].reverse();
 
       let target = null;
       if (messageId) {
         target = messages.find((message) => message?.info?.id === messageId && message?.info?.role === 'assistant');
       }
       if (!target) {
-        for (let i = messages.length - 1; i >= 0; i -= 1) {
-          const message = messages[i];
-          if (message?.info?.role === 'assistant' && message?.info?.finish === 'stop') {
-            target = message;
-            break;
-          }
-        }
+        target = messages.find((message) => (
+          message?.info?.role === 'assistant'
+          && extractTextFromParts(message.parts, maxLength).length > 0
+        ));
       }
 
       if (!target || !Array.isArray(target.parts)) return '';
@@ -175,9 +253,9 @@ export const createNotificationTemplateRuntime = (deps) => {
   };
 
   const cacheSessionTitle = (sessionId, title) => {
-    if (typeof sessionId === 'string' && sessionId.length > 0 && typeof title === 'string' && title.length > 0) {
-      sessionTitleCache.set(sessionId, title);
-    }
+    const id = trimmedText(sessionId);
+    const name = trimmedText(title);
+    if (id && name) sessionTitleCache.set(id, name);
   };
 
   const getCachedSessionTitle = (sessionId) => {
@@ -185,15 +263,12 @@ export const createNotificationTemplateRuntime = (deps) => {
   };
 
   const maybeCacheSessionInfoFromEvent = (payload) => {
-    if (!payload || typeof payload !== 'object') return;
-    const type = payload.type;
-    if (type !== 'session.updated' && type !== 'session.created') return;
-    const info = payload.properties?.info;
-    if (!info || typeof info !== 'object') return;
-    cacheSessionTitle(info.id, info.title);
+    const titled = readSessionTitleFromEvent(payload);
+    if (!titled) return;
+    cacheSessionTitle(titled.sessionId, titled.title);
   };
 
-  const fetchSessionInfo = async (sessionId) => {
+  const fetchSessionInfo = async (sessionId, directory) => {
     if (!sessionId) return null;
 
     const cached = sessionInfoCache.get(sessionId);
@@ -202,20 +277,24 @@ export const createNotificationTemplateRuntime = (deps) => {
     }
 
     try {
-      const url = buildOpenCodeUrl(`/session/${encodeURIComponent(sessionId)}`, '');
+      const base = buildOpenCodeUrl(`/session/${encodeURIComponent(sessionId)}`, '');
+      const url = directory ? `${base}?directory=${encodeURIComponent(directory)}` : base;
       const response = await fetch(url, {
         method: 'GET',
-        headers: { Accept: 'application/json' },
+        headers: {
+          Accept: 'application/json',
+          ...(typeof getOpenCodeAuthHeaders === 'function' ? getOpenCodeAuthHeaders() : {}),
+        },
         signal: AbortSignal.timeout(2000),
       });
       if (!response.ok) {
         console.warn(`[Notification] fetchSessionInfo: ${response.status} for session ${sessionId}`);
         return null;
       }
-      const data = await response.json().catch(() => null);
-      if (data && typeof data === 'object') {
-        sessionInfoCache.set(sessionId, { data, at: Date.now() });
-        return data;
+      const session = readNotificationSessionRecord(await response.json().catch(() => null));
+      if (session) {
+        sessionInfoCache.set(sessionId, { data: session, at: Date.now() });
+        return session;
       }
       return null;
     } catch (error) {
@@ -227,7 +306,11 @@ export const createNotificationTemplateRuntime = (deps) => {
   const buildTemplateVariables = async (payload, sessionId) => {
     const info = payload?.properties?.info || {};
 
-    let sessionTitle = payload?.properties?.sessionTitle || payload?.properties?.session?.title || (typeof info.sessionTitle === 'string' ? info.sessionTitle : '') || '';
+    const fromEvent = readSessionTitleFromEvent(payload);
+    let sessionTitle = trimmedText(payload?.properties?.sessionTitle)
+      || trimmedText(payload?.properties?.session?.title)
+      || trimmedText(info.sessionTitle)
+      || (fromEvent && (!sessionId || fromEvent.sessionId === sessionId) ? fromEvent.title : '');
 
     if (!sessionTitle && sessionId) {
       const cached = getCachedSessionTitle(sessionId);
@@ -238,25 +321,34 @@ export const createNotificationTemplateRuntime = (deps) => {
 
     let sessionInfo = null;
     if (!sessionTitle && sessionId) {
-      sessionInfo = await fetchSessionInfo(sessionId);
-      if (sessionInfo && typeof sessionInfo.title === 'string') {
-        sessionTitle = sessionInfo.title;
+      sessionInfo = await fetchSessionInfo(sessionId, readNotificationDirectory(payload));
+      const fetchedTitle = trimmedText(sessionInfo?.title);
+      if (fetchedTitle) {
+        sessionTitle = fetchedTitle;
         cacheSessionTitle(sessionId, sessionTitle);
       }
     }
 
+    const eventAgent = trimmedText(info.agent) || trimmedText(info.mode);
+    const eventModel = trimmedText(info.modelID)
+      || trimmedText(info.model?.modelID)
+      || trimmedText(info.model?.id);
+    if ((!eventAgent || !eventModel) && sessionId && !sessionInfo) {
+      sessionInfo = await fetchSessionInfo(sessionId, readNotificationDirectory(payload));
+    }
+
     const agentName = (() => {
-      const mode = typeof info.agent === 'string' && info.agent.trim().length > 0
-        ? info.agent.trim()
-        : (typeof info.mode === 'string' ? info.mode.trim() : '');
+      const mode = eventAgent || trimmedText(sessionInfo?.agent) || trimmedText(sessionInfo?.mode);
       if (!mode) return 'Agent';
       return mode.split(/[-_\s]+/).filter(Boolean)
         .map((token) => token.charAt(0).toUpperCase() + token.slice(1)).join(' ');
     })();
 
     const modelName = (() => {
-      const raw = typeof info.modelID === 'string' ? info.modelID.trim()
-        : (typeof info.model?.modelID === 'string' ? info.model.modelID.trim() : '');
+      const raw = eventModel
+        || trimmedText(sessionInfo?.model?.modelID)
+        || trimmedText(sessionInfo?.model?.id)
+        || trimmedText(sessionInfo?.modelID);
       if (!raw) return 'Assistant';
       return raw.split(/[-_]+/).filter(Boolean)
         .map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(' ');

package/server/lib/notifications/template-runtime.test.js

@@ -82,3 +82,99 @@ describe('notification template message extraction', () => {
     await expect(runtime.fetchLastAssistantMessageText('session-1', 'msg-1')).resolves.toBe('final answer');
   });
 });
+
+describe('notification session titles', () => {
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+  });
+
+  it('reads the OpenCode 2 session title from the data envelope', async () => {
+    const runtime = createNotificationTemplateRuntime({
+      readSettingsFromDisk: async () => ({}),
+      buildOpenCodeUrl: (path) => `http://opencode.test${path}`,
+      getOpenCodeAuthHeaders: () => ({ authorization: 'Basic test' }),
+      resolveGitBinaryForSpawn: () => 'git',
+    });
+    globalThis.fetch = vi.fn(async () => new Response(JSON.stringify({
+      data: { id: 'ses_1', title: '发布说明' },
+    })));
+
+    const variables = await runtime.buildTemplateVariables({
+      type: 'message.updated',
+      location: { directory: '/repo' },
+      properties: { info: { sessionID: 'ses_1', role: 'assistant', finish: 'stop' } },
+    }, 'ses_1');
+
+    expect(variables.session_name).toBe('发布说明');
+    expect(globalThis.fetch).toHaveBeenCalledWith(
+      'http://opencode.test/session/ses_1?directory=%2Frepo',
+      expect.objectContaining({
+        headers: expect.objectContaining({ authorization: 'Basic test' }),
+      }),
+    );
+  });
+
+  it('keeps a title learned from session.renamed when the session fetch fails', async () => {
+    const runtime = createRuntime();
+    globalThis.fetch = vi.fn(async () => new Response(null, { status: 401 }));
+    runtime.maybeCacheSessionInfoFromEvent({
+      type: 'session.renamed',
+      data: { sessionID: 'ses_1', title: '修通知标题' },
+    });
+
+    const variables = await runtime.buildTemplateVariables({
+      type: 'session.execution.succeeded',
+      data: { sessionID: 'ses_1' },
+    }, 'ses_1');
+
+    expect(variables.session_name).toBe('修通知标题');
+  });
+
+  it('reads the latest assistant text from an OpenCode 2 message page', async () => {
+    const runtime = createRuntime();
+    globalThis.fetch = vi.fn(async () => new Response(JSON.stringify({
+      data: [
+        {
+          id: 'msg_new',
+          sessionID: 'ses_1',
+          type: 'assistant',
+          agent: 'build',
+          model: { id: 'gpt-5', providerID: 'openai' },
+          content: [
+            { type: 'reasoning', text: 'private' },
+            { type: 'text', text: '发布说明已写好' },
+          ],
+          time: { created: 2 },
+        },
+        {
+          id: 'msg_old',
+          sessionID: 'ses_1',
+          type: 'assistant',
+          content: [{ type: 'text', text: 'older' }],
+          finish: 'stop',
+          time: { created: 1 },
+        },
+      ],
+    })));
+
+    await expect(runtime.fetchLastAssistantMessageText('ses_1')).resolves.toBe('发布说明已写好');
+  });
+
+  it('fills agent and model names from the OpenCode 2 session record', async () => {
+    const runtime = createRuntime();
+    globalThis.fetch = vi.fn(async () => new Response(JSON.stringify({
+      data: { id: 'ses_1', title: '发布说明', agent: 'build', model: { id: 'gpt-5', providerID: 'openai' } },
+    })));
+
+    const variables = await runtime.buildTemplateVariables({
+      type: 'session.execution.succeeded',
+      data: { sessionID: 'ses_1' },
+    }, 'ses_1');
+
+    expect(variables).toMatchObject({
+      session_name: '发布说明',
+      agent_name: 'Build',
+      model_name: 'Gpt 5',
+    });
+  });
+});

package/server/lib/opencode/DOCUMENTATION.md

@@ -15,6 +15,7 @@ This module provides OpenCode server integration utilities for the web server ru
 - `packages/web/server/lib/opencode/managed-capabilities-runtime.js`: managed-child scheduled-task resources, config injection, rotating bridge identity, and bridge authorization.
 - `packages/web/server/lib/opencode/env-runtime.js`: OpenCode CLI/binary resolution and shell environment runtime.
 - `packages/web/server/lib/opencode/ensure-cli.js`: detect local `opencode` version and install the pinned official V2 into the OpenChamber data dir when missing or too old. Never uses a packaged/bundled binary.
+- `packages/web/server/lib/opencode/upgrade-screen.js`: startup gate for a detected OpenCode below `2.0.15`. It does not own process lifecycle. `GET /api/opencode/compatibility` classifies the version already detected by startup. `POST /api/opencode/install-required` installs `max(pin, 2.0.15)` through `installPinnedOpenCode2Cli`, points the managed binary at that cache, and restarts through the existing lifecycle hooks. Success requires the running serve to report `2.0.15` or newer. External serves are not replaced. Failure returns `upgraded: false` and the error; it does not claim the previous process was restored.
 - `packages/web/server/lib/opencode/env-config.js`: OpenCode-related environment variable parsing and validation (host/port/hostname).
 - `packages/web/server/lib/opencode/hmr-state-runtime.js`: HMR-persistent runtime state initialization, auth-state bootstrap, and HMR sync helpers.
 - `packages/web/server/lib/opencode/bootstrap-runtime.js`: base app bootstrap runtime for status/auth/tts/notification/OpenChamber route wiring.
@@ -30,6 +31,7 @@ This module provides OpenCode server integration utilities for the web server ru
 - `packages/web/server/lib/opencode/static-routes-runtime.js`: static asset/SPA fallback route registration and manifest route wiring. The SPA fallback sends `index.html` relative to `root`, so deep links keep working when the install lives under a dot directory.
 - `packages/web/server/lib/opencode/feature-routes-runtime.js`: feature route composition runtime for dynamic import-backed config/skill/provider route registration.
 - `packages/web/server/lib/conversations/`: combined create-session-and-prompt orchestration (OpenChamber-owned, registered before generic proxy).
+- `packages/web/server/lib/browser-provider/`: host for an installed extension that declares `browser`. Lists reachable providers, sends one agent browser action to the selected provider, and refuses when none is selected. Does not drive the in-app browser pane. See `browser-provider/DOCUMENTATION.md`.
 - `packages/web/server/lib/session-turn-pages/`: turn-window session message pagination (`GET /api/openchamber/sessions/:sessionID/messages`), anchor reconcile (`GET .../messages/reconcile`), Changes L2/L3 (`GET .../changes`), and exact message L1 projection (`GET /api/session/:sessionID/message/:messageID`); loops official OpenCode `session.messages` for turn pages and head→anchor gap recovery with continuation/budgets/`resetRequired`; all registered before generic proxy. L1 first-packet / SSE / exact-message paths keep `summary.diffs` as a slim `{ file, status?, additions, deletions }` list plus additive `diffCount`/`hasDiffs` (patch bodies stay on L3). See `session-turn-pages/DOCUMENTATION.md`.
 - `packages/web/server/lib/opencode/opencode-resolution-runtime.js`: OpenCode binary resolution snapshot runtime for settings routes and diagnostics.
 - `packages/web/server/lib/opencode/tunnel-wiring-runtime.js`: active loopback-port wiring shared by pairing/LAN URLs and the private relay host.
@@ -87,6 +89,8 @@ This module provides OpenCode server integration utilities for the web server ru
   - `PUT /api/behavior/agents-md`
   - `POST /api/opencode/upgrade` (ticket 12): installs the pinned/target `@opencode/cli` into the **owned cache** at `~/.config/openchamber/opencode-cli/<version>/`. Managed owned-cache processes restart on that binary; official shared services use that exact binary's `service restart`, then adopt its registration again. Success requires a fresh running-serve version probe and runtime contract verification. Arbitrary external servers, private processes using global CLI, and private bundled binaries return HTTP 409; user installs are never overwritten. Concurrent upgrades are single-flight (`operation` state). Active sessions require `confirmActiveTasks`/`force`. Failure preserves cached binaries, restores the previous binary selection, and reports the failed phase; it does not claim the old process was restored. Shared-service recovery can subsequently re-ensure the registered service.
   - `GET /api/opencode/upgrade-status`: returns `currentVersion`/`serveVersion`/`cliVersion`, `targetVersion`/`latestVersion` (pin), `supplySource`, `ownership`, `canManage`, `management`, `guidance`, `contract`, and `operation`. Official shared services report `ownership: 'shared-service'`, `processOwnership: 'shared'`, and `canManage: true`. `available` is true only when `canManage` and target > current; unmanaged global/external runtimes report `available: null` plus manual guidance.
+  - `GET /api/opencode/compatibility`: startup upgrade-screen status. `state` is `compatible` at OpenCode `2.0.15` or newer, `incompatible` when a detected version is older or not 2.x, and `unavailable` when no version could be read. `canInstall` is true only for a local (managed or bundled) runtime this platform can install into the owned cache. External serves are reported and not replaced.
+  - `POST /api/opencode/install-required`: installs the upgrade-screen target (`2.0.15`, or the pin when the pin is newer) into the owned cache and restarts through the existing lifecycle. `upgraded: true` only after the running serve verifies at or above that target. Failure is `upgraded: false` plus `error`. Concurrent installs are single-flight.
   - `GET /api/opencode/contract` (ticket 11): runtime contract admission for the **running serve** (not health alone). Dimensions: reachable / authenticated / protocolCompatible / executionAllowed / capabilities / migration / CLI↔serve mismatch. Floor `2.0.12` (acceptable OpenCode 2.x at or above); below-min 2.x and 1.x block execution with upgrade guidance; no upper version cap.
   - `GET /api/opencode/health`: probes managed OpenCode `GET /api/info` (Basic auth, 4s timeout). `healthy` is reachability/version shape via `evaluateOpenCodeHealthBody` (admits official 2.x `ServerInfo` and classic `{ healthy: true, version }`; rejects 1.x / missing / `healthy: false`). Response also includes `executionAllowed`, `protocolCompatible`, and `contract` so clients do not treat health success as full execution semantics. Upstream non-OK responses pass through status with `{ healthy: false, error, contract }`; transport failures return HTTP 503.
   - `GET /api/opencode/version`: serve + CLI versions, mismatch flag, and contract snapshot
@@ -305,6 +309,10 @@ configuration reload uses official SDK `location.reload`. The historical
 `/api/config/reload` host/bridge endpoint remains reserved for existing process
 startup/recovery/binary-change callers, not ordinary Settings mutations.
 
+Command catalog SDK fetch forwarding preserves the generated request options,
+including authentication headers, and combines caller cancellation with its
+eight-second request deadline.
+
 `config-hot-reload.integration.test.js` is opt-in via
 `OPENCHAMBER_TEST_OPENCODE_BINARY=<absolute-v2-cli>`. It starts a separate loopback
 server with isolated HOME/XDG/config/database, checks global command changes,

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

@@ -531,7 +531,12 @@ export const registerConfigEntityRoutes = (app, dependencies) => {
         const client = createOpenCodeClient({
           baseUrl: buildOpenCodeUrl('/', '').replace(/\/$/, ''),
           headers: getOpenCodeAuthHeaders(),
-          fetch: (request) => fetch(request, { signal: AbortSignal.timeout(8_000) }),
+          fetch: (request, init) => fetch(request, {
+            ...init,
+            signal: init?.signal
+              ? AbortSignal.any([init.signal, AbortSignal.timeout(8_000)])
+              : AbortSignal.timeout(8_000),
+          }),
         });
         const response = await client.command.list({ location: { directory } });
         if (!Array.isArray(response?.data)) {

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

@@ -69,6 +69,31 @@ describe('V2 configuration persistence', () => {
 });
 
 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());

package/server/lib/opencode/ensure-cli.d.ts

@@ -0,0 +1,8 @@
+export function readOpenCode2BinaryVersion(binaryPath: string): string;
+
+export function installPinnedOpenCode2Cli(options?: {
+  version?: string;
+  platform?: string;
+  arch?: string;
+  dataDir?: string;
+}): Promise<string>;

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

@@ -19,6 +19,9 @@ 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';
@@ -513,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

@@ -54,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/proxy.js

@@ -957,7 +957,9 @@ export const registerOpenCodeProxy = (app, deps) => {
       req.path === '/opencode/version' ||
       req.path === '/opencode/contract' ||
       req.path === '/opencode/upgrade-status' ||
-      req.path === '/opencode/upgrade'
+      req.path === '/opencode/upgrade' ||
+      req.path === '/opencode/compatibility' ||
+      req.path === '/opencode/install-required'
     ) {
       return next();
     }
@@ -1207,6 +1209,9 @@ export const registerOpenCodeProxy = (app, deps) => {
   app.get('/api/session/:sessionID/message', (req, res, next) => {
     return forwardSessionMessagesListRequest(req, res, next);
   });
+  app.get('/api/session/:sessionID/context', (req, res, next) => {
+    return forwardSessionMessagesListRequest(req, res, next);
+  });
 
   app.get('/api/global/event', forwardSseRequest);
   app.get('/api/event', forwardSseRequest);

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

@@ -460,6 +460,21 @@ describe('registerOpenCodeProxy reasoning projection routes', () => {
     expect(JSON.stringify(res.body)).not.toContain('hidden');
   });
 
+  it.each(['message', 'context'])('filters native v2 %s before outbound transport', async (surface) => {
+    const upstreamUrls = [];
+    globalThis.fetch = vi.fn(async (url) => {
+      upstreamUrls.push(String(url));
+      return new Response(JSON.stringify({ data: [{ id: 'm', type: 'assistant', content: [
+        { type: 'reasoning', text: 'hidden' }, { type: 'text', text: 'visible' },
+      ] }], cursor: { next: 'older' } }), { headers: { 'content-type': 'application/json' } });
+    });
+    const res = await request(mountProxy()).get(`/api/session/ses_1/${surface}?includeReasoning=false`);
+    expect(res.status).toBe(200);
+    expect(res.body.data[0].content).toEqual([{ type: 'text', text: 'visible' }]);
+    expect(res.body.cursor.next).toBe('older');
+    expect(upstreamUrls[0]).not.toContain('includeReasoning');
+  });
+
   it('keeps reasoning parts on session.messages list when includeReasoning is omitted', async () => {
     globalThis.fetch = vi.fn(async () => ({
       ok: true,
@@ -503,7 +518,7 @@ describe('registerOpenCodeProxy session metadata overlay', () => {
     return app;
   };
 
-  it('merges Host store metadata onto session list and detail (store keys win)', async () => {
+  it('merges side-store gaps onto the OpenCode record without letting the side row win conflicts', async () => {
     globalThis.fetch = vi.fn(async (url) => {
       const path = String(url).split('?')[0];
       if (path.endsWith('/api/session') || path.endsWith('/session')) {
@@ -551,7 +566,7 @@ describe('registerOpenCodeProxy session metadata overlay', () => {
       id: 'ses_1',
       metadata: {
         fromOpenCode: true,
-        shared: 'ours',
+        shared: 'theirs',
         openchamber: { goal: { status: 'active' } },
       },
     });
@@ -563,7 +578,7 @@ describe('registerOpenCodeProxy session metadata overlay', () => {
       id: 'ses_1',
       metadata: {
         fromOpenCode: true,
-        shared: 'ours',
+        shared: 'theirs',
         openchamber: { goal: { status: 'active' } },
       },
     });

package/server/lib/opencode/routes.js

@@ -11,6 +11,7 @@ import {
   readOpenCode2BinaryVersion,
   resolveOpenChamberDataDir,
 } from './ensure-cli.js';
+import { registerUpgradeScreenRoutes } from './upgrade-screen.js';
 import { evaluateRuntimeContract } from './runtime-contract.js';
 import {
   buildUpgradeStatusSnapshot,
@@ -253,6 +254,35 @@ export const registerOpenCodeRoutes = (app, dependencies) => {
     return fallback;
   };
 
+  registerUpgradeScreenRoutes(app, {
+    resolveOwnership: resolveOwnershipContext,
+    readServeVersion: async () => {
+      const probe = await readOpenCodeCurrentVersion().catch(() => ({ currentVersion: null }));
+      return probe.currentVersion || null;
+    },
+    readCliVersion: () => {
+      const fromRuntime = typeof getOpenCodeCliVersion === 'function' ? getOpenCodeCliVersion() : null;
+      if (fromRuntime) return fromRuntime;
+      const binaryPath = typeof getResolvedOpenCodeBinary === 'function' ? getResolvedOpenCodeBinary() : null;
+      return binaryPath ? readOpenCode2BinaryVersion(binaryPath) : null;
+    },
+    readConfiguredBinary: async () => {
+      const settings = await readSettingsFromDiskMigrated();
+      return typeof settings?.opencodeBinary === 'string' ? settings.opencodeBinary : null;
+    },
+    persistBinary: async (binaryPath) => {
+      await persistSettings({ opencodeBinary: binaryPath });
+    },
+    getResolvedBinary: getResolvedOpenCodeBinary,
+    getResolvedBinarySource: getResolvedOpenCodeBinarySource,
+    forceBinary: typeof forceResolvedOpenCodeBinary === 'function' ? forceResolvedOpenCodeBinary : null,
+    restart: typeof restartOpenCode === 'function' ? restartOpenCode : null,
+    waitReady: typeof waitForOpenCodeReady === 'function' ? waitForOpenCodeReady : null,
+    isSharedService: () => getIsSharedOpenCodeService() === true,
+    install: (options) => installPinnedOpenCode2Cli({ ...options, dataDir: resolveDataDir() }),
+    readBinaryVersion: readOpenCode2BinaryVersion,
+  });
+
   app.get('/api/config/settings', async (req, res) => {
     try {
       const settings = await readSettingsFromDiskMigrated();

package/server/lib/opencode/upgrade-screen.d.ts

@@ -0,0 +1,30 @@
+export const REQUIRED_OPENCODE_VERSION: string;
+
+export type UpgradeScreen = {
+  state: 'unavailable' | 'compatible' | 'incompatible';
+  version: string | null;
+  installation: 'managed' | 'external' | 'bundled';
+  minimumVersion: string;
+  targetVersion: string;
+  canInstall: boolean;
+  guidance: string | null;
+};
+
+export function describeUpgradeScreen(input?: {
+  version?: string | null;
+  installation?: 'managed' | 'external' | 'bundled';
+  platformCanInstall?: boolean;
+  guidance?: string | null;
+  pin?: string;
+}): UpgradeScreen;
+
+export function platformSupportsUpgradeScreenInstall(platform?: string, arch?: string): boolean;
+
+export function installRequiredOpenCode(deps: object): Promise<{
+  ok: true;
+  upgraded: true;
+  version: string;
+  targetVersion: string;
+  error: null;
+  errorCode: null;
+}>;