@vantran-se/openchamber-web 1.24.3 → 2.0.1

package/server/opencode-proxy.test.js

@@ -27,8 +27,10 @@ const closeServer = (server) => new Promise((resolve, reject) => {
 describe('OpenCode proxy SSE forwarding', () => {
   let upstreamServer;
   let proxyServer;
+  const originalPlatform = Object.getOwnPropertyDescriptor(process, 'platform');
 
   afterEach(async () => {
+    Object.defineProperty(process, 'platform', originalPlatform);
     await closeServer(proxyServer);
     await closeServer(upstreamServer);
     proxyServer = undefined;
@@ -39,7 +41,7 @@ describe('OpenCode proxy SSE forwarding', () => {
     let seenAuthorization = null;
 
     const upstream = express();
-    upstream.get('/global/event', (req, res) => {
+    upstream.get('/api/event', (req, res) => {
       seenAuthorization = req.headers.authorization ?? null;
       res.setHeader('Content-Type', 'text/event-stream; charset=utf-8');
       res.setHeader('Cache-Control', 'private, max-age=0');
@@ -85,7 +87,7 @@ describe('OpenCode proxy SSE forwarding', () => {
   it('closes downstream SSE when the OpenCode upstream stalls despite proxy heartbeats', async () => {
     let stallTimeoutReads = 0;
     const upstream = express();
-    upstream.get('/global/event', (_req, res) => {
+    upstream.get('/api/event', (_req, res) => {
       res.setHeader('Content-Type', 'text/event-stream');
       res.flushHeaders();
       setTimeout(() => res.write(':upstream-alive\n\n'), 40);
@@ -133,7 +135,7 @@ describe('OpenCode proxy SSE forwarding', () => {
 
   it('holds a request through OpenCode warmup and succeeds once ready (no 503/backoff)', async () => {
     const upstream = express();
-    upstream.get('/config/providers', (_req, res) => {
+    upstream.get('/api/config/providers', (_req, res) => {
       res.json({ ok: true });
     });
     upstreamServer = await listen(upstream);
@@ -227,7 +229,7 @@ describe('OpenCode proxy SSE forwarding', () => {
 
   it('routes generic API requests through external OpenCode base URL', async () => {
     const upstream = express();
-    upstream.get('/config/providers', (_req, res) => {
+    upstream.get('/api/config/providers', (_req, res) => {
       res.json({ ok: true, source: 'external-host' });
     });
     upstreamServer = await listen(upstream);
@@ -262,7 +264,7 @@ describe('OpenCode proxy SSE forwarding', () => {
 
   it('replays parsed urlencoded bodies to generic API proxy requests', async () => {
     const upstream = express();
-    upstream.post('/form', express.urlencoded({ extended: true }), (req, res) => {
+    upstream.post('/api/form', express.urlencoded({ extended: true }), (req, res) => {
       res.json({ body: req.body });
     });
     upstreamServer = await listen(upstream);
@@ -302,7 +304,7 @@ describe('OpenCode proxy SSE forwarding', () => {
 
   it('replays parsed JSON bodies to generic API proxy requests', async () => {
     const upstream = express();
-    upstream.post('/session/abc/prompt_async', express.json(), (req, res) => {
+    upstream.post('/api/session/abc/prompt', express.json(), (req, res) => {
       res.json({
         body: req.body,
         authorization: req.headers.authorization,
@@ -335,7 +337,7 @@ describe('OpenCode proxy SSE forwarding', () => {
     const proxyPort = proxyServer.address().port;
 
     const payload = { messageID: 'msg_1', parts: [{ type: 'text', text: 'hello' }] };
-    const response = await fetch(`http://127.0.0.1:${proxyPort}/api/session/abc/prompt_async`, {
+    const response = await fetch(`http://127.0.0.1:${proxyPort}/api/session/abc/prompt`, {
       method: 'POST',
       headers: { 'content-type': 'application/json' },
       body: JSON.stringify(payload),
@@ -348,44 +350,44 @@ describe('OpenCode proxy SSE forwarding', () => {
     expect(Number(data.contentLength)).toBeGreaterThan(0);
   });
 
-  it('sanitizes experimental session list responses and forwards query params', async () => {
+  it.each([
+    ['win32', ''],
+    ['win32', '&directory=%2Flink%2Frepo'],
+    ['linux', ''],
+    ['linux', '&directory=%2Flink%2Frepo'],
+  ])('sanitizes session pages and forwards query params (%s, %s)', async (platform, directoryQuery) => {
+    Object.defineProperty(process, 'platform', { value: platform, configurable: true });
     let seenQuery = null;
     let seenAuth = null;
 
     const upstream = express();
-    upstream.get('/experimental/session', (req, res) => {
+    upstream.get('/api/session', (req, res) => {
       seenQuery = req.query;
       seenAuth = req.headers.authorization ?? null;
       res.setHeader('X-Next-Cursor', '123');
-      res.json([
-        {
-          id: 'ses_1',
-          slug: 'alpha',
-          projectID: 'proj_1',
-          workspaceID: 'ws_1',
-          directory: '/repo/app',
-          path: '/repo/app',
-          parentID: 'ses_parent',
-          title: 'Alpha',
-          agent: 'build',
-          model: { id: 'gpt-5', providerID: 'openai', variant: 'default' },
-          version: '1.0.0',
-          time: { created: 1, updated: 2 },
-          cost: 7,
-          tokens: { input: 10, output: 20 },
-          share: { url: 'https://share.example/ses_1' },
-          project: { id: 'proj_1', worktree: '/repo/app' },
-          summary: {
-            additions: 5,
-            deletions: 3,
-            files: 2,
-            diffs: [{ patch: '@@ -1 +1 @@', additions: 5, deletions: 3 }],
+      res.json({
+        data: [
+          {
+            id: 'ses_1',
+            projectID: 'proj_1',
+            location: { directory: '/repo/app', workspaceID: 'ws_1' },
+            subpath: 'app',
+            parentID: 'ses_parent',
+            title: 'Alpha',
+            agent: 'build',
+            model: { id: 'gpt-5', providerID: 'openai', variant: 'default' },
+            time: { created: 1, updated: 2, archived: 3 },
+            cost: 7,
+            tokens: { input: 10, output: 20 },
+            outcome: 'succeeded',
+            fork: { sessionID: 'ses_source', boundary: { type: 'through' } },
+            metadata: { openchamber: { kind: 'review', originalSessionID: 'ses_original' } },
+            permissions: [{ action: 'deny', resources: ['*'] }],
+            revert: { messageID: 'msg_1', partID: 'part_1', snapshot: 'abc123', files: ['a.ts'] },
           },
-          metadata: { openchamber: { kind: 'review', originalSessionID: 'ses_original' } },
-          permission: [{ permission: 'todowrite', action: 'deny', pattern: '*' }],
-          revert: { messageID: 'msg_1', partID: 'part_1', snapshot: 'abc123', diff: 'diff --git a/x b/x' },
-        },
-      ]);
+        ],
+        cursor: { next: '123' },
+      });
     });
     upstreamServer = await listen(upstream);
     const upstreamPort = upstreamServer.address().port;
@@ -415,74 +417,104 @@ describe('OpenCode proxy SSE forwarding', () => {
     proxyServer = await listen(app);
     const proxyPort = proxyServer.address().port;
 
-    const response = await fetch(`http://127.0.0.1:${proxyPort}/api/experimental/session?archived=false&limit=500&cursor=99&roots=true&directory=%2Flink%2Frepo`);
+    const response = await fetch(`http://127.0.0.1:${proxyPort}/api/session?archived=false&limit=500&cursor=99&roots=true${directoryQuery}`);
 
     expect(response.status).toBe(200);
     expect(response.headers.get('x-next-cursor')).toBe('123');
     expect(seenAuth).toBe('Bearer session-token');
-    expect(seenQuery).toMatchObject({
+    const expectedQuery = {
       archived: 'false',
       limit: '500',
       cursor: '99',
       roots: 'true',
-      directory: '/real/repo',
-    });
-
-    await expect(response.json()).resolves.toEqual([
-      {
-        id: 'ses_1',
-        slug: 'alpha',
-        projectID: 'proj_1',
-        workspaceID: 'ws_1',
-        directory: '/repo/app',
-        path: '/repo/app',
-        parentID: 'ses_parent',
-        title: 'Alpha',
-        agent: 'build',
-        model: { id: 'gpt-5', providerID: 'openai', variant: 'default' },
-        version: '1.0.0',
-        time: { created: 1, updated: 2 },
-        cost: 7,
-        tokens: { input: 10, output: 20 },
-        share: { url: 'https://share.example/ses_1' },
-        metadata: { openchamber: { kind: 'review', originalSessionID: 'ses_original' } },
-        project: { id: 'proj_1', worktree: '/repo/app' },
-        summary: { additions: 5, deletions: 3, files: 2 },
-        revert: { messageID: 'msg_1', partID: 'part_1' },
-      },
-    ]);
+    };
+    if (directoryQuery) expectedQuery.directory = '/real/repo';
+    expect(seenQuery).toEqual(expectedQuery);
+
+    // The heavy parts of a revert and the per-session permission ruleset are
+    // dropped; everything the list view reads survives.
+    await expect(response.json()).resolves.toEqual({
+      data: [
+        {
+          id: 'ses_1',
+          projectID: 'proj_1',
+          location: { directory: '/repo/app', workspaceID: 'ws_1' },
+          subpath: 'app',
+          parentID: 'ses_parent',
+          title: 'Alpha',
+          agent: 'build',
+          model: { id: 'gpt-5', providerID: 'openai', variant: 'default' },
+          time: { created: 1, updated: 2, archived: 3 },
+          cost: 7,
+          tokens: { input: 10, output: 20 },
+          outcome: 'succeeded',
+          fork: { sessionID: 'ses_source', boundary: { type: 'through' } },
+          metadata: { openchamber: { kind: 'review', originalSessionID: 'ses_original' } },
+          revert: { messageID: 'msg_1', partID: 'part_1' },
+        },
+      ],
+      cursor: { next: '123' },
+    });
+  });
+
+  it.each([
+    [200, { data: [], cursor: {} }],
+    [503, { error: 'Upstream unavailable' }],
+  ])('preserves Windows global list status and empty/error payload (%s)', async (status, payload) => {
+    Object.defineProperty(process, 'platform', { value: 'win32', configurable: true });
+    const upstream = express();
+    upstream.get('/api/session', (_req, res) => res.status(status).json(payload));
+    upstreamServer = await listen(upstream);
+    const upstreamPort = upstreamServer.address().port;
+    const baseUrl = `http://127.0.0.1:${upstreamPort}`;
+    const app = express();
+    registerOpenCodeProxy(app, {
+      fs: {},
+      OPEN_CODE_READY_GRACE_MS: 0,
+      getRuntime: () => ({
+        openCodePort: upstreamPort,
+        openCodeBaseUrl: baseUrl,
+        isOpenCodeReady: true,
+        openCodeNotReadySince: 0,
+        isRestartingOpenCode: false,
+      }),
+      getOpenCodeAuthHeaders: () => ({}),
+      buildOpenCodeUrl: (requestPath) => `${baseUrl}${requestPath}`,
+      ensureOpenCodeApiPrefix: () => {},
+    });
+    proxyServer = await listen(app);
+    const response = await fetch(`http://127.0.0.1:${proxyServer.address().port}/api/session?limit=1`);
+    expect(response.status).toBe(status);
+    expect(await response.json()).toEqual(payload);
   });
 
   it('sanitizes session list responses without sanitizing session detail responses', async () => {
     let seenListQuery = null;
 
     const upstream = express();
-    upstream.get('/session', (req, res) => {
+    upstream.get('/api/session', (req, res) => {
       seenListQuery = req.query;
-      res.json([
-        {
-          id: 'ses_1',
-          directory: '/repo/app',
-          title: 'Alpha',
-          time: { created: 1, updated: 2 },
-          summary: {
-            additions: 5,
-            deletions: 3,
-            files: 2,
-            diffs: [{ patch: '@@ -1 +1 @@', additions: 5, deletions: 3 }],
+      res.json({
+        data: [
+          {
+            id: 'ses_1',
+            location: { directory: '/repo/app' },
+            title: 'Alpha',
+            time: { created: 1, updated: 2 },
+            metadata: { custom: { value: 'kept' } },
+            permissions: [{ action: 'deny', resources: ['*'] }],
+            revert: { messageID: 'msg_1', partID: 'part_1', snapshot: 'abc123', files: ['a.ts'] },
           },
-          metadata: { custom: { value: 'kept' } },
-          revert: { messageID: 'msg_1', partID: 'part_1', snapshot: 'abc123', diff: 'diff --git a/x b/x' },
-        },
-      ]);
+        ],
+        cursor: {},
+      });
     });
-    upstream.get('/session/abc', (_req, res) => {
+    upstream.get('/api/session/abc', (_req, res) => {
       res.json({
         id: 'abc',
-        directory: '/repo/app',
+        location: { directory: '/repo/app' },
         title: 'Detail',
-        summary: { diffs: [{ patch: '@@ -1 +1 @@' }] },
-        revert: { messageID: 'msg_1', snapshot: 'abc123', diff: 'diff --git a/x b/x' },
+        revert: { messageID: 'msg_1', snapshot: 'abc123', files: ['a.ts'] },
       });
     });
     upstreamServer = await listen(upstream);
@@ -517,79 +549,48 @@ describe('OpenCode proxy SSE forwarding', () => {
 
     expect(listResponse.status).toBe(200);
     expect(seenListQuery).toMatchObject({ directory: '/real/repo' });
-    await expect(listResponse.json()).resolves.toEqual([
-      {
-        id: 'ses_1',
-        directory: '/repo/app',
-        title: 'Alpha',
-        time: { created: 1, updated: 2 },
-        summary: { additions: 5, deletions: 3, files: 2 },
-        metadata: { custom: { value: 'kept' } },
-        revert: { messageID: 'msg_1', partID: 'part_1' },
-      },
-    ]);
+    await expect(listResponse.json()).resolves.toEqual({
+      data: [
+        {
+          id: 'ses_1',
+          location: { directory: '/repo/app' },
+          title: 'Alpha',
+          time: { created: 1, updated: 2 },
+          metadata: { custom: { value: 'kept' } },
+          revert: { messageID: 'msg_1', partID: 'part_1' },
+        },
+      ],
+      cursor: {},
+    });
 
     const detailResponse = await fetch(`http://127.0.0.1:${proxyPort}/api/session/abc`);
 
     expect(detailResponse.status).toBe(200);
     await expect(detailResponse.json()).resolves.toEqual({
       id: 'abc',
-      directory: '/repo/app',
+      location: { directory: '/repo/app' },
       title: 'Detail',
-      summary: { diffs: [{ patch: '@@ -1 +1 @@' }] },
-      revert: { messageID: 'msg_1', snapshot: 'abc123', diff: 'diff --git a/x b/x' },
+      revert: { messageID: 'msg_1', snapshot: 'abc123', files: ['a.ts'] },
     });
   });
 
-  it('forwards unparsed SDK JSON bodies to generic API proxy requests', async () => {
+  it('folds OpenChamber-owned archive state and metadata onto sessions it serves', async () => {
     const upstream = express();
-    upstream.post('/session/abc/revert', express.json(), (req, res) => {
+    upstream.get('/api/session', (_req, res) => {
       res.json({
-        body: req.body,
-        contentLength: req.headers['content-length'],
+        data: [
+          { id: 'ses_1', location: { directory: '/repo/app' }, title: 'Alpha', time: { created: 1, updated: 2 }, metadata: { fromOpenCode: true, shared: 'theirs', removed: 'stale' } },
+          { id: 'ses_2', location: { directory: '/repo/app' }, title: 'Beta', time: { created: 1, updated: 3, archived: 999 }, metadata: { openchamber: { reviewSessionID: 'ses_old' } } },
+          { id: 'ses_3', metadata: { untouched: true } },
+        ],
+        cursor: {},
       });
     });
-    upstreamServer = await listen(upstream);
-    const upstreamPort = upstreamServer.address().port;
-    const externalBaseUrl = `http://127.0.0.1:${upstreamPort}`;
-
-    const app = express();
-    registerOpenCodeProxy(app, {
-      fs: {},
-      os: {},
-      path,
-      OPEN_CODE_READY_GRACE_MS: 0,
-      getRuntime: () => ({
-        openCodePort: upstreamPort,
-        openCodeBaseUrl: externalBaseUrl,
-        isOpenCodeReady: true,
-        openCodeNotReadySince: 0,
-        isRestartingOpenCode: false,
-      }),
-      getOpenCodeAuthHeaders: () => ({}),
-      buildOpenCodeUrl: (requestPath) => `${externalBaseUrl}${requestPath}`,
-      ensureOpenCodeApiPrefix: () => {},
-    });
-    proxyServer = await listen(app);
-    const proxyPort = proxyServer.address().port;
-
-    const payload = { messageID: 'msg_1' };
-    const response = await fetch(`http://127.0.0.1:${proxyPort}/api/session/abc/revert`, {
-      method: 'POST',
-      headers: { 'content-type': 'application/json' },
-      body: JSON.stringify(payload),
+    upstream.get('/api/session/ses_1', (_req, res) => {
+      res.json({ id: 'ses_1', location: { directory: '/repo/app' }, title: 'Alpha', metadata: { fromOpenCode: true, shared: 'theirs', removed: 'stale' } });
     });
-
-    expect(response.status).toBe(200);
-    const data = await response.json();
-    expect(data.body).toEqual(payload);
-    expect(Number(data.contentLength)).toBeGreaterThan(0);
-  });
-
-  it('uses the long proxy timeout budget for slow upstream responses', async () => {
-    const upstream = express();
-    upstream.get('/slow', (_req, _res) => {
-      // Leave the response open so the proxy timeout path is exercised.
+    upstream.get('/api/session/ses_2', (_req, res) => {
+      res.json({ id: 'ses_2', metadata: { openchamber: { reviewSessionID: 'ses_old' } } });
     });
     upstreamServer = await listen(upstream);
     const upstreamPort = upstreamServer.address().port;
@@ -601,7 +602,6 @@ describe('OpenCode proxy SSE forwarding', () => {
       os: {},
       path,
       OPEN_CODE_READY_GRACE_MS: 0,
-      LONG_REQUEST_TIMEOUT_MS: 50,
       getRuntime: () => ({
         openCodePort: upstreamPort,
         openCodeBaseUrl: externalBaseUrl,
@@ -612,24 +612,48 @@ describe('OpenCode proxy SSE forwarding', () => {
       getOpenCodeAuthHeaders: () => ({}),
       buildOpenCodeUrl: (requestPath) => `${externalBaseUrl}${requestPath}`,
       ensureOpenCodeApiPrefix: () => {},
+      getArchivedSessions: async () => ({ ses_1: 4242 }),
+      getStoredSessionMetadata: async () => ({
+        ses_1: { fromOpenCode: true, openchamber: { goal: { status: 'active' } }, shared: 'ours' },
+        ses_2: {},
+      }),
     });
     proxyServer = await listen(app);
     const proxyPort = proxyServer.address().port;
 
-    const response = await fetch(`http://127.0.0.1:${proxyPort}/api/slow`, {
-      signal: AbortSignal.timeout(2000),
-    });
-
-    expect(response.status).toBe(504);
-    await expect(response.json()).resolves.toMatchObject({ error: 'OpenCode upstream timed out' });
+    const list = await (await fetch(`http://127.0.0.1:${proxyPort}/api/session`)).json();
+    // The seeded metadata includes unchanged upstream fields but excludes
+    // deleted keys. Empty metadata is authoritative too.
+    expect(list.data[0]).toMatchObject({
+      id: 'ses_1',
+      time: { created: 1, updated: 2, archived: 4242 },
+      metadata: { fromOpenCode: true, shared: 'ours', openchamber: { goal: { status: 'active' } } },
+    });
+    expect(list.data[0].metadata).not.toHaveProperty('removed');
+    expect(list.data[1].metadata).toEqual({});
+    expect(list.data[2].metadata).toEqual({ untouched: true });
+    // The archive file does not mention ses_2, so the stamp OpenCode carries
+    // (a session migrated from v1) stays as it is.
+    expect(list.data[1].time).toEqual({ created: 1, updated: 3, archived: 999 });
+
+    const detail = await (await fetch(`http://127.0.0.1:${proxyPort}/api/session/ses_1`)).json();
+    expect(detail).toMatchObject({
+      id: 'ses_1',
+      time: { archived: 4242 },
+      metadata: { fromOpenCode: true, shared: 'ours', openchamber: { goal: { status: 'active' } } },
+    });
+    expect(detail.metadata).not.toHaveProperty('removed');
+    const cleared = await (await fetch(`http://127.0.0.1:${proxyPort}/api/session/ses_2`)).json();
+    expect(cleared.metadata).toEqual({});
   });
 
-  it('exempts interactive provider OAuth callbacks from the request deadline', async () => {
+  it('forwards unparsed SDK JSON bodies to generic API proxy requests', async () => {
     const upstream = express();
-    // Stands in for upstream blocking until the user finishes signing in.
-    upstream.post('/provider/:providerID/oauth/callback', async (_req, res) => {
-      await new Promise((resolve) => setTimeout(resolve, 250));
-      res.json(true);
+    upstream.post('/api/session/abc/revert', express.json(), (req, res) => {
+      res.json({
+        body: req.body,
+        contentLength: req.headers['content-length'],
+      });
     });
     upstreamServer = await listen(upstream);
     const upstreamPort = upstreamServer.address().port;
@@ -641,7 +665,6 @@ describe('OpenCode proxy SSE forwarding', () => {
       os: {},
       path,
       OPEN_CODE_READY_GRACE_MS: 0,
-      LONG_REQUEST_TIMEOUT_MS: 50,
       getRuntime: () => ({
         openCodePort: upstreamPort,
         openCodeBaseUrl: externalBaseUrl,
@@ -656,20 +679,22 @@ describe('OpenCode proxy SSE forwarding', () => {
     proxyServer = await listen(app);
     const proxyPort = proxyServer.address().port;
 
-    const response = await fetch(`http://127.0.0.1:${proxyPort}/api/provider/github-copilot/oauth/callback`, {
+    const payload = { messageID: 'msg_1' };
+    const response = await fetch(`http://127.0.0.1:${proxyPort}/api/session/abc/revert`, {
       method: 'POST',
       headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ method: 0 }),
-      signal: AbortSignal.timeout(5000),
+      body: JSON.stringify(payload),
     });
 
     expect(response.status).toBe(200);
-    await expect(response.json()).resolves.toBe(true);
+    const data = await response.json();
+    expect(data.body).toEqual(payload);
+    expect(Number(data.contentLength)).toBeGreaterThan(0);
   });
 
-  it('still applies the request deadline to the OAuth authorize call', async () => {
+  it('uses the long proxy timeout budget for slow upstream responses', async () => {
     const upstream = express();
-    upstream.post('/provider/:providerID/oauth/authorize', (_req, _res) => {
+    upstream.get('/api/slow', (_req, _res) => {
       // Leave the response open so the proxy timeout path is exercised.
     });
     upstreamServer = await listen(upstream);
@@ -697,13 +722,12 @@ describe('OpenCode proxy SSE forwarding', () => {
     proxyServer = await listen(app);
     const proxyPort = proxyServer.address().port;
 
-    const response = await fetch(`http://127.0.0.1:${proxyPort}/api/provider/github-copilot/oauth/authorize`, {
-      method: 'POST',
-      headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ method: 0 }),
+    const response = await fetch(`http://127.0.0.1:${proxyPort}/api/slow`, {
       signal: AbortSignal.timeout(2000),
     });
 
     expect(response.status).toBe(504);
+    await expect(response.json()).resolves.toMatchObject({ error: 'OpenCode upstream timed out' });
   });
+
 });

package/server/opencode-worktree-readiness.test.js

@@ -36,11 +36,12 @@ async function createFixture({ timeoutMs = 1000 } = {}) {
     instance ??= bootstrap.phase === 'directory-created'
       ? { projectID: 'global', config: {} }
       : { projectID: 'project-3464', config: projectConfig };
-    if (req.path === '/config') return res.json(instance.config);
-    if (req.path === '/session' && req.method === 'POST') {
+    if (req.path === '/api/config') return res.json(instance.config);
+    if (req.path === '/api/session' && req.method === 'POST') {
       return res.json({ projectID: instance.projectID, directory: req.query.directory, title: req.body.title });
     }
-    res.json([]);
+    // v2 pages the session list as `{ data, cursor }`.
+    res.json({ data: [], cursor: {} });
   });
   const upstreamUrl = await listen(upstream);
   const app = express();
@@ -91,7 +92,7 @@ describe('issue #3464 worktree OpenCode initialization', () => {
     expect(fixture.forwarded).toEqual([]);
     fixture.setBootstrap({ status: 'ready', phase: 'setup-ready', error: null });
     expect((await response).status).toBe(200);
-    expect(fixture.forwarded).toEqual(['/session']);
+    expect(fixture.forwarded).toEqual(['/api/session']);
   });
 
   it('does not block unrelated directories while a worktree is pending', async () => {