@vantran-se/openchamber-web 1.24.4 → 2.0.2

package/server/lib/openchamber-control/file-open.js

@@ -0,0 +1,59 @@
+/**
+ * The agent asking the user to look at a file.
+ *
+ * The viewer lives in a renderer, so the server cannot open anything itself;
+ * it checks that the file is really there and tells every connected client to
+ * show it. No answer comes back: opening a tab is not something that fails
+ * quietly on the client, and the agent only needs to know whether anyone was
+ * there to see it.
+ */
+import path from 'node:path';
+import fsPromises from 'node:fs/promises';
+
+import { OpenChamberControlError } from './error.js';
+
+/**
+ * @param {{
+ *   emit: (request: { path: string, directory: string | null, sessionId: string | null }) => number,
+ *   stat?: (target: string) => Promise<{ isFile(): boolean, size: number }>,
+ * }} dependencies
+ */
+export const createFileOpenRequester = ({ emit, stat = (target) => fsPromises.stat(target) }) => {
+  /** `path` arrives already reduced to a trimmed string or null by the service. */
+  const request = async ({ path: raw, directory, sessionId }) => {
+    if (!raw) throw new OpenChamberControlError('path is required for file.open', 400);
+
+    // A relative path means "in the project I am working in"; without a
+    // project there is nothing to resolve it against.
+    let absolute;
+    if (path.isAbsolute(raw)) {
+      absolute = path.normalize(raw);
+    } else if (directory) {
+      absolute = path.resolve(directory, raw);
+    } else {
+      throw new OpenChamberControlError('path must be absolute when no session directory is known', 400);
+    }
+
+    let stats;
+    try {
+      stats = await stat(absolute);
+    } catch (error) {
+      if (error?.code === 'ENOENT') {
+        throw new OpenChamberControlError(`File not found: ${absolute}`, 404);
+      }
+      throw new OpenChamberControlError(`Cannot read ${absolute}: ${error instanceof Error ? error.message : String(error)}`, 500);
+    }
+    if (!stats.isFile()) {
+      throw new OpenChamberControlError(`Not a file: ${absolute}`, 400);
+    }
+
+    const delivered = emit({ path: absolute, directory: directory ?? null, sessionId: sessionId ?? null });
+    if (delivered === 0) {
+      throw new OpenChamberControlError('No OpenChamber window is connected to show the file', 503);
+    }
+
+    return { path: absolute, size: stats.size, opened: true };
+  };
+
+  return { request };
+};

package/server/lib/openchamber-control/file-open.test.js

@@ -0,0 +1,57 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { createFileOpenRequester } from './file-open.js';
+
+const file = { isFile: () => true, size: 42 };
+
+describe('createFileOpenRequester', () => {
+  it('resolves a relative path against the session directory and tells the clients', async () => {
+    const emit = vi.fn(() => 2);
+    const stat = vi.fn(async () => file);
+    const requester = createFileOpenRequester({ emit, stat });
+
+    const result = await requester.request({ path: 'out/report.csv', directory: '/repo', sessionId: 'ses_1' });
+
+    expect(stat).toHaveBeenCalledWith('/repo/out/report.csv');
+    expect(emit).toHaveBeenCalledWith({ path: '/repo/out/report.csv', directory: '/repo', sessionId: 'ses_1' });
+    expect(result).toEqual({ path: '/repo/out/report.csv', size: 42, opened: true });
+  });
+
+  it('keeps an absolute path outside the project, which is where screenshots and recordings often land', async () => {
+    const emit = vi.fn(() => 1);
+    const requester = createFileOpenRequester({ emit, stat: async () => file });
+
+    const result = await requester.request({ path: '/tmp/shot.png', directory: '/repo', sessionId: null });
+
+    expect(result.path).toBe('/tmp/shot.png');
+    expect(emit).toHaveBeenCalledWith({ path: '/tmp/shot.png', directory: '/repo', sessionId: null });
+  });
+
+  it('refuses a relative path when no directory is known, instead of guessing one', async () => {
+    const requester = createFileOpenRequester({ emit: () => 1, stat: async () => file });
+    await expect(requester.request({ path: 'report.csv', directory: null, sessionId: null }))
+      .rejects.toMatchObject({ statusCode: 400 });
+  });
+
+  it('reports a missing file and a directory before asking anyone to open them', async () => {
+    const emit = vi.fn(() => 1);
+    const missing = createFileOpenRequester({
+      emit,
+      stat: async () => { throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' }); },
+    });
+    await expect(missing.request({ path: '/repo/gone.png', directory: '/repo' }))
+      .rejects.toMatchObject({ statusCode: 404 });
+
+    const folder = createFileOpenRequester({ emit, stat: async () => ({ isFile: () => false, size: 0 }) });
+    await expect(folder.request({ path: '/repo/src', directory: '/repo' }))
+      .rejects.toMatchObject({ statusCode: 400 });
+
+    expect(emit).not.toHaveBeenCalled();
+  });
+
+  it('fails with 503 when no client is connected rather than claiming the file was shown', async () => {
+    const requester = createFileOpenRequester({ emit: () => 0, stat: async () => file });
+    await expect(requester.request({ path: '/repo/a.png', directory: '/repo' }))
+      .rejects.toMatchObject({ statusCode: 503 });
+  });
+});

package/server/lib/openchamber-control/routes.test.js

@@ -2,6 +2,7 @@ import express from 'express';
 import request from 'supertest';
 import { describe, expect, it, vi } from 'vitest';
 
+import { BrowserControlError } from '../browser-control/broker.js';
 import { OpenChamberControlError } from './error.js';
 import { registerOpenChamberControlRoutes } from './routes.js';
 
@@ -43,4 +44,15 @@ describe('OpenChamber control route', () => {
       directory: '/repo',
     });
   });
+
+  it('keeps the status of a browser refusal instead of reporting 500', async () => {
+    const execute = vi.fn(async () => {
+      throw new BrowserControlError('The user is interacting with this page in the panel right now.', 409);
+    });
+    const response = await request(createApp(execute))
+      .post('/api/openchamber/control')
+      .send({ action: 'browser.click', input: {} })
+      .expect(409);
+    expect(response.body).toEqual({ error: 'The user is interacting with this page in the panel right now.' });
+  });
 });

package/server/lib/openchamber-control/service.js

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { createOpencodeClient } from '@opencode-ai/sdk/v2';
+import { OpenCode } from '@opencode/client';
 import { OpenChamberControlError, asControlError } from './error.js';
 import { OPENCHAMBER_ALL_ACTIONS } from './actions.js';
 import { writeScreenshot } from './screenshots.js';
@@ -38,23 +38,32 @@ const normalizeWaitTimeoutMs = (value) => {
   return seconds * 1000;
 };
 
+// v2 messages are not { info, parts }: the record itself is the message, a
+// user message carries `text`, and an assistant message carries `content[]`
+// whose text items are the visible answer.
+const messageText = (record) => {
+  if (record.type === 'user') return typeof record.text === 'string' ? record.text.trim() : '';
+  return (Array.isArray(record.content) ? record.content : [])
+    .filter((item) => item?.type === 'text' && typeof item.text === 'string')
+    .map((item) => item.text)
+    .join('')
+    .trim();
+};
+
 const extractTextMessages = (messages, role = 'all') => {
   const result = [];
   for (const record of Array.isArray(messages) ? messages : []) {
-    const info = record?.info;
-    const messageRole = info?.role;
+    const messageRole = record?.type;
     if ((messageRole !== 'user' && messageRole !== 'assistant') || (role !== 'all' && role !== messageRole)) continue;
-    const text = Array.isArray(record?.parts)
-      ? record.parts.filter((part) => part?.type === 'text' && typeof part.text === 'string').map((part) => part.text).join('').trim()
-      : '';
+    const text = messageText(record);
     if (!text) continue;
-    const providerID = asNonEmptyString(info.providerID);
-    const modelID = asNonEmptyString(info.modelID);
+    const providerID = asNonEmptyString(record.model?.providerID);
+    const modelID = asNonEmptyString(record.model?.id);
     result.push({
-      id: asNonEmptyString(info.id) || '',
+      id: asNonEmptyString(record.id) || '',
       role: messageRole,
-      createdAt: Number.isFinite(info?.time?.created) ? info.time.created : null,
-      completedAt: Number.isFinite(info?.time?.completed) ? info.time.completed : null,
+      createdAt: Number.isFinite(record?.time?.created) ? record.time.created : null,
+      completedAt: Number.isFinite(record?.time?.completed) ? record.time.completed : null,
       model: providerID && modelID ? `${providerID}/${modelID}` : null,
       text,
     });
@@ -144,8 +153,12 @@ export const createOpenChamberControlService = (dependencies) => {
     sessionService,
     scheduledTaskService,
     browserControl = null,
+    fileOpen = null,
     agentMemoryActions = null,
-    createClient = createOpencodeClient,
+    // Archive lives in OpenChamber's own store now — v2 has no route that sets
+    // Session.time.archived — so an unwired store simply means nothing is archived.
+    archiveStore = null,
+    createClient = OpenCode.make,
     sleep = (duration) => new Promise((resolve) => setTimeout(resolve, duration)),
     now = Date.now,
   } = dependencies;
@@ -169,14 +182,25 @@ export const createOpenChamberControlService = (dependencies) => {
     });
   };
 
-  const getClient = async () => {
+  // Every v2 route lives under /api and the client appends it, so it only
+  // wants the origin. Per-directory scoping is a request header.
+  const getClient = async (directory = '') => {
     if (typeof waitForOpenCodeReady === 'function') await waitForOpenCodeReady(10_000, 250);
     return createClient({
-      baseUrl: buildOpenCodeUrl('/', '').replace(/\/$/, ''),
-      headers: getOpenCodeAuthHeaders(),
+      baseUrl: new URL(buildOpenCodeUrl('/api/info', '')).origin,
+      headers: {
+        ...getOpenCodeAuthHeaders(),
+        ...(directory ? { 'x-opencode-directory': encodeURIComponent(directory) } : {}),
+      },
+      fetch,
     });
   };
 
+  const archivedAt = (sessionID) => {
+    if (!archiveStore || typeof archiveStore.isArchived !== 'function') return null;
+    return archiveStore.isArchived(sessionID) || null;
+  };
+
   const projects = async () => {
     const settings = await readSettingsFromDiskMigrated();
     return sanitizeProjects(settings?.projects || []).map((project) => ({
@@ -197,22 +221,32 @@ export const createOpenChamberControlService = (dependencies) => {
     };
   };
 
-  const sessionStatus = async (client, sessionID, directory) => {
-    const response = await client.session.status({ directory });
-    const statuses = response?.data;
+  // /api/session/active is global in v2 and reports only `{ type: 'running' }`.
+  // The action contract stays busy/idle, so running is reported as busy.
+  const activeSessions = async (client) => {
+    const statuses = await client.session.active();
     if (!statuses || typeof statuses !== 'object' || Array.isArray(statuses)) {
       throw new OpenChamberControlError('Invalid session status response', 500);
     }
-    return statuses[sessionID] || { type: 'idle' };
+    return statuses;
   };
 
-  const sessionMessages = async (client, sessionID, directory, role, limit) => {
+  const asPublicStatus = (active) => (active ? { type: 'busy' } : { type: 'idle' });
+
+  const sessionStatus = async (client, sessionID) => {
+    const statuses = await activeSessions(client);
+    return asPublicStatus(statuses[sessionID]);
+  };
+
+  // `order: 'desc'` puts the newest messages in the limited page;
+  // extractTextMessages re-sorts them oldest-first for the caller.
+  const sessionMessages = async (client, sessionID, role, limit) => {
     const fetchLimit = limit === undefined ? undefined : Math.max(100, limit * 4);
-    let response = await client.session.messages({ sessionID, directory, ...(fetchLimit ? { limit: fetchLimit } : {}) });
+    let response = await client.message.list({ sessionID, ...(fetchLimit ? { limit: fetchLimit, order: 'desc' } : {}) });
     let raw = Array.isArray(response?.data) ? response.data : [];
     let messages = extractTextMessages(raw, role);
     if (limit !== undefined && messages.length < limit && raw.length >= fetchLimit) {
-      response = await client.session.messages({ sessionID, directory });
+      response = await client.message.list({ sessionID });
       raw = Array.isArray(response?.data) ? response.data : [];
       messages = extractTextMessages(raw, role);
     }
@@ -224,13 +258,13 @@ export const createOpenChamberControlService = (dependencies) => {
     let observedActivity = false;
     while (true) {
       if (signal?.aborted) throw new OpenChamberControlError('OpenChamber action was cancelled', 499);
-      const status = await sessionStatus(client, sessionID, directory);
-      if (status.type === 'busy' || status.type === 'retry') {
+      const status = await sessionStatus(client, sessionID);
+      if (status.type === 'busy') {
         observedActivity = true;
       } else if (!requireActivity || observedActivity) {
         return status;
       } else {
-        const messages = await sessionMessages(client, sessionID, directory, 'assistant', 1);
+        const messages = await sessionMessages(client, sessionID, 'assistant', 1);
         const message = messages[0];
         if (message?.completedAt && (baselineMessageID ? message.id !== baselineMessageID : message.completedAt >= startedAt)) {
           return status;
@@ -245,17 +279,17 @@ export const createOpenChamberControlService = (dependencies) => {
   };
 
   // session.send/fork default the directory to the caller's context directory,
-  // which is wrong for sessions living in other worktrees: prompt_async then
+  // which is wrong for sessions living in other worktrees: the prompt then
   // targets an instance that does not hold the session and the run dies with
   // UnknownError. Resolve the target session's directory from the global
   // session list when the caller did not scope explicitly.
   const resolveSessionDirectory = async (sessionID) => {
     try {
       const client = await getClient();
-      const response = await client.experimental?.session?.list?.({});
+      const response = await client.session.list({});
       const sessions = Array.isArray(response?.data) ? response.data : [];
       const session = sessions.find((item) => item?.id === sessionID);
-      return asNonEmptyString(session?.directory) || null;
+      return asNonEmptyString(session?.location?.directory) || null;
     } catch {
       return null;
     }
@@ -305,7 +339,7 @@ export const createOpenChamberControlService = (dependencies) => {
       delete publicResult.baselineAssistantMessageId;
       return publicResult;
     }
-    const client = await getClient();
+    const client = await getClient(result.directory);
     const status = await waitForIdle({
       client,
       sessionID: result.sessionId,
@@ -319,7 +353,7 @@ export const createOpenChamberControlService = (dependencies) => {
     const publicResult = { ...result, sessionStatus: status };
     delete publicResult.baselineAssistantMessageId;
     if (input.lastAssistant === true) {
-      publicResult.lastAssistantMessage = (await sessionMessages(client, result.sessionId, result.directory, 'assistant', 1))[0] || null;
+      publicResult.lastAssistantMessage = (await sessionMessages(client, result.sessionId, 'assistant', 1))[0] || null;
     }
     return publicResult;
   };
@@ -329,7 +363,7 @@ export const createOpenChamberControlService = (dependencies) => {
    * should come back as a usage error the agent can correct, without waking a
    * client or waiting for a round trip.
    */
-  const browserAction = async (action, input, signal, contextDirectory) => {
+  const browserAction = async (action, input, signal, contextDirectory, contextSessionId) => {
     const parameters = {};
 
     const readViewport = (required) => {
@@ -417,7 +451,13 @@ export const createOpenChamberControlService = (dependencies) => {
     // exceed the client's own wait; sharing one timeout with the quick actions
     // made a slow page indistinguishable from an unreachable browser.
     const timeoutMs = action === 'browser.open' ? 45_000 : 20_000;
-    const result = await browserControl.request(action, parameters, { signal, timeoutMs });
+    // Where the call came from, for a provider that keeps one browser per
+    // project or chat. Filled by the tool plugin, never by the model.
+    const context = {
+      directory: asNonEmptyString(contextDirectory),
+      sessionId: asNonEmptyString(contextSessionId),
+    };
+    const result = await browserControl.request(action, parameters, { signal, timeoutMs, context });
 
     // The image is written here rather than in the renderer: the file belongs
     // beside the code it documents, and the client that took it may be on a
@@ -469,7 +509,17 @@ export const createOpenChamberControlService = (dependencies) => {
         if (!browserControl) {
           throw new OpenChamberControlError('The in-app browser is not available on this server', 503);
         }
-        return browserAction(action, input, options.signal, contextDirectory);
+        return browserAction(action, input, options.signal, contextDirectory, options.contextSessionId);
+      }
+      if (action === 'file.open') {
+        if (!fileOpen) {
+          throw new OpenChamberControlError('The file viewer is not available on this server', 503);
+        }
+        return fileOpen.request({
+          path: asNonEmptyString(input.path),
+          directory: asNonEmptyString(input.directory) || asNonEmptyString(contextDirectory),
+          sessionId: asNonEmptyString(options.contextSessionId),
+        });
       }
       if (action === 'projects.list') return { projects: await projects() };
       if (action === 'models.list') return models();
@@ -514,24 +564,24 @@ export const createOpenChamberControlService = (dependencies) => {
       if (action.startsWith('session.')) {
         const directory = asNonEmptyString(input.directory) || asNonEmptyString(contextDirectory);
         const sessionID = asNonEmptyString(input.sessionId);
-        const client = await getClient();
+        const client = await getClient(directory);
         if (action === 'session.list') {
           const limit = positiveInteger(input.limit, 10, 'limit');
           const response = await client.session.list(directory ? { directory } : {});
-          let sessions = Array.isArray(response?.data) ? response.data : [];
+          // Archive is OpenChamber state; overlay it so callers keep reading
+          // it off the session the way OpenCode used to report it.
+          let sessions = (Array.isArray(response?.data) ? response.data : []).map((session) => {
+            const archived = archivedAt(session?.id);
+            return archived ? { ...session, time: { ...session.time, archived } } : session;
+          });
           if (input.all !== true) sessions = sessions.filter((session) => !session?.time?.archived);
           sessions = sessions.slice(0, limit);
           if (input.withStatus === true) {
-            const cache = new Map();
-            sessions = await Promise.all(sessions.map(async (session) => {
-              const sessionDirectory = asNonEmptyString(session?.directory);
-              if (!sessionDirectory) return { ...session, status: { type: 'unknown' } };
-              if (!cache.has(sessionDirectory)) {
-                const statusRequest = client.session.status({ directory: sessionDirectory }).catch(() => null);
-                cache.set(sessionDirectory, statusRequest);
-              }
-              const statusResponse = await cache.get(sessionDirectory);
-              return { ...session, status: statusResponse?.data?.[session.id] || (statusResponse ? { type: 'idle' } : { type: 'unknown' }) };
+            // One global call now: v2 reports active sessions across directories.
+            const statuses = await activeSessions(client).catch(() => null);
+            sessions = sessions.map((session) => ({
+              ...session,
+              status: statuses ? asPublicStatus(statuses[session.id]) : { type: 'unknown' },
             }));
           }
           return { sessions, limit, directory, archived: input.all === true ? 'included' : 'excluded' };
@@ -539,7 +589,7 @@ export const createOpenChamberControlService = (dependencies) => {
         if (!sessionID) throw new OpenChamberControlError('sessionId is required', 400);
         if (!directory) throw new OpenChamberControlError('directory is required', 400);
         if (action === 'session.status') {
-          return { sessionId: sessionID, directory, sessionStatus: await sessionStatus(client, sessionID, directory) };
+          return { sessionId: sessionID, directory, sessionStatus: await sessionStatus(client, sessionID) };
         }
         if (action === 'session.messages') {
           if (input.timeout !== undefined && input.wait !== true) throw new OpenChamberControlError('timeout requires wait', 400);
@@ -550,9 +600,9 @@ export const createOpenChamberControlService = (dependencies) => {
           if (last && input.limit !== undefined) throw new OpenChamberControlError('last cannot be combined with limit', 400);
           const currentStatus = input.wait === true
             ? await waitForIdle({ client, sessionID, directory, timeoutMs: normalizeWaitTimeoutMs(input.timeout), requireActivity: false, startedAt: now(), signal: options.signal })
-            : await sessionStatus(client, sessionID, directory);
+            : await sessionStatus(client, sessionID);
           const limit = input.all === true ? undefined : (last ? 1 : positiveInteger(input.limit, 10, 'limit'));
-          return { sessionId: sessionID, directory, role, sessionStatus: currentStatus, messages: await sessionMessages(client, sessionID, directory, role, limit) };
+          return { sessionId: sessionID, directory, role, sessionStatus: currentStatus, messages: await sessionMessages(client, sessionID, role, limit) };
         }
       }
       throw new OpenChamberControlError(`Unsupported OpenChamber action: ${action || 'missing'}`, 400);
@@ -561,5 +611,8 @@ export const createOpenChamberControlService = (dependencies) => {
     }
   };
 
-  return { execute };
+  // The managed agent-tool plugin can no longer report the session's directory
+  // (v2 dropped `context.directory` from a tool call), so it sends the session
+  // id and the directory is resolved here, where it is authoritative.
+  return { execute, resolveSessionDirectory };
 };

package/server/lib/openchamber-control/service.test.js

@@ -10,8 +10,10 @@ const createService = (overrides = {}) => {
   const client = {
     session: {
       list: vi.fn(async () => ({ data: [] })),
-      status: vi.fn(async () => ({ data: {} })),
-      messages: vi.fn(async () => ({ data: [] })),
+      active: vi.fn(async () => ({})),
+    },
+    message: {
+      list: vi.fn(async () => ({ data: [] })),
     },
   };
   const sessionService = {
@@ -137,20 +139,12 @@ describe('OpenChamber control service', () => {
   });
 
   it('resolves the target session directory from the global session list when send omits it', async () => {
-    const { service, sessionService, client } = createService({
-      createClient: () => ({
-        ...client,
-        experimental: {
-          session: {
-            list: vi.fn(async () => ({
-              data: [
-                { id: 'ses_other', directory: '/repo/worktrees/other' },
-                { id: 'ses_target', directory: '/repo/worktrees/target' },
-              ],
-            })),
-          },
-        },
-      }),
+    const { service, sessionService, client } = createService();
+    client.session.list.mockResolvedValue({
+      data: [
+        { id: 'ses_other', location: { directory: '/repo/worktrees/other' } },
+        { id: 'ses_target', location: { directory: '/repo/worktrees/target' } },
+      ],
     });
     sessionService.send.mockResolvedValue({ sessionId: 'ses_target', directory: '/repo/worktrees/target', promptDispatched: true });
 
@@ -160,12 +154,7 @@ describe('OpenChamber control service', () => {
   });
 
   it('falls back to the context directory when the session is not in the global list', async () => {
-    const { service, sessionService, client } = createService({
-      createClient: () => ({
-        ...client,
-        experimental: { session: { list: vi.fn(async () => ({ data: [] })) } },
-      }),
-    });
+    const { service, sessionService } = createService();
     sessionService.send.mockResolvedValue({ sessionId: 'ses_unknown', directory: '/repo', promptDispatched: true });
 
     await service.execute('session.send', { sessionId: 'ses_unknown', prompt: 'Continue' }, '/repo');
@@ -185,11 +174,11 @@ describe('OpenChamber control service', () => {
       promptDispatched: true,
       baselineAssistantMessageId: 'msg_old',
     });
-    client.session.status.mockResolvedValue({ data: { ses_1: { type: 'idle' } } });
-    client.session.messages
-      .mockResolvedValueOnce({ data: [{ info: { id: 'msg_old', role: 'assistant', time: { completed: 900 } }, parts: [{ type: 'text', text: 'old' }] }] })
-      .mockResolvedValueOnce({ data: [{ info: { id: 'msg_new', role: 'assistant', time: { completed: 1500 } }, parts: [{ type: 'text', text: 'done' }] }] })
-      .mockResolvedValueOnce({ data: [{ info: { id: 'msg_new', role: 'assistant', time: { completed: 1500 } }, parts: [{ type: 'text', text: 'done' }] }] });
+    client.session.active.mockResolvedValue({});
+    client.message.list
+      .mockResolvedValueOnce({ data: [{ id: 'msg_old', type: 'assistant', time: { completed: 900 }, content: [{ type: 'text', text: 'old' }] }] })
+      .mockResolvedValueOnce({ data: [{ id: 'msg_new', type: 'assistant', time: { completed: 1500 }, content: [{ type: 'text', text: 'done' }] }] })
+      .mockResolvedValueOnce({ data: [{ id: 'msg_new', type: 'assistant', time: { completed: 1500 }, content: [{ type: 'text', text: 'done' }] }] });
 
     await expect(service.execute('session.create', {
       directory: '/repo',
@@ -201,24 +190,24 @@ describe('OpenChamber control service', () => {
       sessionStatus: { type: 'idle' },
       lastAssistantMessage: expect.objectContaining({ id: 'msg_new', text: 'done' }),
     }));
-    expect(client.session.status).toHaveBeenCalledTimes(2);
+    expect(client.session.active).toHaveBeenCalledTimes(2);
   });
 
-  it('filters archived sessions and adds directory-scoped statuses', async () => {
-    const { service, client } = createService();
+  it('filters sessions archived in OpenChamber state and adds global statuses', async () => {
+    const { service, client } = createService({
+      archiveStore: { isArchived: (id) => (id === 'ses_archived' ? 100 : null) },
+    });
     client.session.list.mockResolvedValue({ data: [
-      { id: 'ses_active', directory: '/repo', time: {} },
-      { id: 'ses_archived', directory: '/repo', time: { archived: 100 } },
-      { id: 'ses_other', directory: '/other', time: {} },
+      { id: 'ses_active', location: { directory: '/repo' }, time: {} },
+      { id: 'ses_archived', location: { directory: '/repo' }, time: {} },
+      { id: 'ses_other', location: { directory: '/other' }, time: {} },
     ] });
-    client.session.status
-      .mockResolvedValueOnce({ data: { ses_active: { type: 'busy' } } })
-      .mockRejectedValueOnce(new Error('unavailable'));
+    client.session.active.mockResolvedValue({ ses_active: { type: 'running' } });
 
     await expect(service.execute('session.list', { limit: 10, withStatus: true })).resolves.toEqual({
       sessions: [
-        { id: 'ses_active', directory: '/repo', time: {}, status: { type: 'busy' } },
-        { id: 'ses_other', directory: '/other', time: {}, status: { type: 'unknown' } },
+        { id: 'ses_active', location: { directory: '/repo' }, time: {}, status: { type: 'busy' } },
+        { id: 'ses_other', location: { directory: '/other' }, time: {}, status: { type: 'idle' } },
       ],
       limit: 10,
       directory: null,
@@ -226,21 +215,34 @@ describe('OpenChamber control service', () => {
     });
   });
 
+  it('reports unknown status when the active-session read fails', async () => {
+    const { service, client } = createService();
+    client.session.list.mockResolvedValue({ data: [{ id: 'ses_active', location: { directory: '/repo' }, time: {} }] });
+    client.session.active.mockRejectedValue(new Error('unavailable'));
+
+    await expect(service.execute('session.list', { limit: 10, withStatus: true })).resolves.toEqual({
+      sessions: [{ id: 'ses_active', location: { directory: '/repo' }, time: {}, status: { type: 'unknown' } }],
+      limit: 10,
+      directory: null,
+      archived: 'excluded',
+    });
+  });
+
   it('names limit in positive-integer validation errors', async () => {
     const { service, client } = createService();
     await expect(service.execute('session.list', { limit: 0 })).rejects.toThrow('limit must be a positive integer');
     expect(client.session.list).not.toHaveBeenCalled();
   });
 
-  it('projects only ordered text parts from session messages', async () => {
+  it('projects only ordered text content from session messages', async () => {
     const { service, client } = createService();
-    client.session.messages.mockResolvedValue({ data: [
+    client.message.list.mockResolvedValue({ data: [
       {
-        info: { id: 'msg_assistant', role: 'assistant', providerID: 'openai', modelID: 'gpt-5.4-mini', time: { created: 20, completed: 30 } },
-        parts: [{ type: 'reasoning', text: 'hidden' }, { type: 'text', text: 'First ' }, { type: 'tool' }, { type: 'text', text: 'answer' }],
+        id: 'msg_assistant', type: 'assistant', model: { providerID: 'openai', id: 'gpt-5.4-mini' }, time: { created: 20, completed: 30 },
+        content: [{ type: 'reasoning', text: 'hidden' }, { type: 'text', text: 'First ' }, { type: 'tool' }, { type: 'text', text: 'answer' }],
       },
-      { info: { id: 'msg_user', role: 'user', time: { created: 10 } }, parts: [{ type: 'text', text: 'Question' }] },
-      { info: { id: 'msg_tool', role: 'assistant', time: { created: 15 } }, parts: [{ type: 'tool' }] },
+      { id: 'msg_user', type: 'user', time: { created: 10 }, text: 'Question' },
+      { id: 'msg_tool', type: 'assistant', time: { created: 15 }, content: [{ type: 'tool' }] },
     ] });
 
     await expect(service.execute('session.messages', {
@@ -266,6 +268,32 @@ describe('OpenChamber control service', () => {
   });
 });
 
+describe('file.open', () => {
+  it('hands the path, the session directory and the session to the file viewer', async () => {
+    const request = vi.fn(async () => ({ path: '/repo/out.csv', size: 3, opened: true }));
+    const { service } = createService({ fileOpen: { request } });
+
+    const result = await service.execute('file.open', { path: 'out.csv' }, '/repo', { contextSessionId: 'ses_1' });
+
+    expect(request).toHaveBeenCalledWith({ path: 'out.csv', directory: '/repo', sessionId: 'ses_1' });
+    expect(result).toEqual({ path: '/repo/out.csv', size: 3, opened: true });
+  });
+
+  it('lets an explicit directory win over the session directory', async () => {
+    const request = vi.fn(async () => ({ path: '/other/out.csv', size: 3, opened: true }));
+    const { service } = createService({ fileOpen: { request } });
+
+    await service.execute('file.open', { path: 'out.csv', directory: '/other' }, '/repo');
+
+    expect(request).toHaveBeenCalledWith({ path: 'out.csv', directory: '/other', sessionId: null });
+  });
+
+  it('answers 503 when this server has no file viewer wired', async () => {
+    const { service } = createService({});
+    await expect(service.execute('file.open', { path: 'out.csv' }, '/repo')).rejects.toMatchObject({ statusCode: 503 });
+  });
+});
+
 describe('browser capture', () => {
   const pixel = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==';
 
@@ -315,4 +343,16 @@ describe('browser capture', () => {
     await service.execute('browser.capture', { label: 'before' }, directory);
     expect(request).toHaveBeenCalledWith('browser.capture', { label: 'before' }, expect.anything());
   });
+
+  it('tells the browser which project and chat the action came from', async () => {
+    const { service, directory, request } = await createBrowserService({ base64: pixel, mime: 'image/png' });
+    await service.execute('browser.capture', {}, directory, { contextSessionId: 'ses_1' });
+    expect(request).toHaveBeenCalledWith('browser.capture', {}, expect.objectContaining({
+      context: { directory, sessionId: 'ses_1' },
+    }));
+    await service.execute('browser.capture', {}, directory);
+    expect(request).toHaveBeenLastCalledWith('browser.capture', {}, expect.objectContaining({
+      context: { directory, sessionId: null },
+    }));
+  });
 });