@aiworker/web 1.23.0 → 1.23.1

package/server/lib/session-assist/runtime.test.js

@@ -0,0 +1,203 @@
+import { createServer } from 'node:http';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { createSessionAssistRuntime } from './runtime.js';
+
+const resources = [];
+const message = (id, role, text, extra = {}) => ({
+  info: { id, role, parentID: 'user', finish: 'stop', time: { completed: 1 }, providerID: 'test-provider', modelID: 'test-model', ...extra },
+  parts: [{ type: 'text', text }],
+});
+const output = (recap = 'Зміни готові', suggestion = '') => ({ text: JSON.stringify({ recap, suggestion }), providerID: 'test-provider', modelID: 'test-model' });
+const pause = () => new Promise((resolve) => setTimeout(resolve, 15));
+
+async function fixture(generate = async () => output()) {
+  const state = {
+    messages: [message('user', 'user', 'Виправ помилку'), message('answer', 'assistant', 'Виправлено')],
+    session: { id: 'session', directory: '/project', time: {}, metadata: { external: 'keep', aiworker: { note: 'keep' } } },
+    targets: { recap: true, suggestion: true },
+    gets: 0, failFresh: false, patches: [], requests: [], calls: [],
+  };
+  const server = createServer(async (request, response) => {
+    const url = new URL(request.url, 'http://localhost');
+    state.requests.push({ method: request.method, directory: url.searchParams.get('directory'), limit: url.searchParams.get('limit'), auth: request.headers['x-test-auth'] });
+    response.setHeader('content-type', 'application/json');
+    if (request.method === 'PATCH') {
+      const chunks = [];
+      for await (const chunk of request) chunks.push(chunk);
+      state.patches.push(JSON.parse(Buffer.concat(chunks).toString()));
+      response.end(JSON.stringify(state.session));
+    } else if (url.pathname.endsWith('/message')) {
+      response.end(JSON.stringify(url.searchParams.get('limit') === '1' ? state.messages.slice(-1) : state.messages));
+    } else {
+      state.gets++;
+      response.statusCode = state.failFresh && state.gets > 1 ? 500 : 200;
+      response.end(JSON.stringify(state.session));
+    }
+  });
+  await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+  const base = `http://127.0.0.1:${server.address().port}`;
+  state.base = base;
+  const runtime = createSessionAssistRuntime({
+    buildOpenCodeUrl: (route) => state.base + route,
+    getOpenCodeAuthHeaders: () => ({ 'x-test-auth': 'fixture' }),
+    getTargets: () => state.targets,
+    quietMs: 1,
+    getSmallModelService: async () => ({
+      describeSmallModel: async () => ({ inputCharBudget: 64_000 }),
+      generateSmallModelText: async (args) => { state.calls.push(args); return generate(args, state); },
+    }),
+  });
+  resources.push({ runtime, server });
+  const status = (type) => runtime.processPayload({ type: 'session.status', properties: { sessionID: 'session', status: { type } } }, '/project');
+  return { state, runtime, status };
+}
+
+afterEach(async () => {
+  for (const { runtime, server } of resources.splice(0)) {
+    runtime.stop();
+    server.closeAllConnections();
+    await new Promise((resolve) => server.close(resolve));
+  }
+  vi.restoreAllMocks();
+});
+
+describe('session assist runtime', () => {
+  it('uses bounded authenticated SDK reads and preserves metadata with an empty suggestion', async () => {
+    const { state, status } = await fixture(async (_args, current) => {
+      current.session.metadata.aiworker.concurrent = 'new';
+      return output();
+    });
+    status('idle');
+    await vi.waitFor(() => expect(state.patches).toHaveLength(1));
+    expect(state.requests.every((r) => r.directory === '/project' && r.auth === 'fixture')).toBe(true);
+    expect(state.requests.filter((r) => r.limit).map((r) => r.limit)).toEqual(['50', '1']);
+    expect(state.calls[0]).toMatchObject({ restrictToPreferredProvider: true, onOverflow: 'error', preferredProviderID: 'test-provider', preferredModelID: 'test-model', sessionID: 'session' });
+    expect(state.patches[0].metadata).toMatchObject({ external: 'keep', aiworker: {
+      note: 'keep', concurrent: 'new', assist: { recap: 'Зміни готові', suggestion: '', forMessageID: 'answer' },
+    } });
+  });
+
+  it('does no work with both settings off and skips child, archived, or reverted sessions', async () => {
+    const { state, status } = await fixture();
+    state.targets = { recap: false, suggestion: false };
+    status('idle');
+    await pause();
+    expect(state.requests).toHaveLength(0);
+    state.targets.recap = true;
+    state.session.parentID = 'parent';
+    status('idle');
+    await vi.waitFor(() => expect(state.gets).toBe(1));
+    delete state.session.parentID;
+    state.session.revert = { messageID: 'user' };
+    status('idle');
+    await vi.waitFor(() => expect(state.gets).toBe(2));
+    delete state.session.revert;
+    state.session.time.archived = 1;
+    status('idle');
+    await vi.waitFor(() => expect(state.gets).toBe(3));
+    expect(state.calls).toHaveLength(0);
+  });
+
+  it('keeps recent context for recap-only and performs no write for an empty suggestion-only result', async () => {
+    const { state, status } = await fixture();
+    state.targets.suggestion = false;
+    state.messages.unshift(message('previous-user', 'user', 'Попередня задача'), message('previous-answer', 'assistant', 'Зміст зробленого', { parentID: 'previous-user' }));
+    status('idle');
+    await vi.waitFor(() => expect(state.patches).toHaveLength(1));
+    expect(state.calls[0].prompt).toContain('Зміст зробленого');
+    expect(state.calls[0].system).not.toContain('suggestion');
+    state.targets = { recap: false, suggestion: true };
+    status('idle');
+    await vi.waitFor(() => expect(state.calls).toHaveLength(2));
+    await pause();
+    expect(state.patches).toHaveLength(1);
+  });
+
+  it('does not write a stale result when the tail moves during generation', async () => {
+    const { state, status } = await fixture(async (_args, current) => {
+      current.messages.push(message('new-user', 'user', 'Нова задача'));
+      return output();
+    });
+    status('idle');
+    await vi.waitFor(() => expect(state.requests.some((r) => r.limit === '1')).toBe(true));
+    await pause();
+    expect(state.patches).toHaveLength(0);
+  });
+
+  it('does not fall back to stale metadata when the fresh read fails', async () => {
+    const warning = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const { state, status } = await fixture();
+    state.failFresh = true;
+    status('idle');
+    await vi.waitFor(() => expect(warning).toHaveBeenCalled());
+    expect(state.gets).toBe(2);
+    expect(state.patches).toHaveLength(0);
+  });
+
+  it('cancels old work and retains an expired newer idle timer until it can run', async () => {
+    const releases = [];
+    const { state, status } = await fixture(() => new Promise((resolve) => releases.push(resolve)));
+    status('idle');
+    await vi.waitFor(() => expect(releases).toHaveLength(1));
+    status('busy');
+    expect(state.calls[0].signal.aborted).toBe(true);
+    state.messages.push(message('next-user', 'user', 'Далі'), message('next-answer', 'assistant', 'Готово', { parentID: 'next-user' }));
+    status('idle');
+    await pause();
+    releases[0](output('Старий результат'));
+    await vi.waitFor(() => expect(releases).toHaveLength(2));
+    expect(state.patches).toHaveLength(0);
+    releases[1](output('Новий результат'));
+    await vi.waitFor(() => expect(state.patches).toHaveLength(1));
+    expect(state.patches[0].metadata.aiworker.assist).toMatchObject({ recap: 'Новий результат', forMessageID: 'next-answer' });
+  });
+
+  it('aborts on stop and honors settings switched off during generation', async () => {
+    let release;
+    const { state, runtime, status } = await fixture(() => new Promise((resolve) => { release = resolve; }));
+    status('idle');
+    await vi.waitFor(() => expect(state.calls).toHaveLength(1));
+    runtime.stop();
+    expect(state.calls[0].signal.aborted).toBe(true);
+    release(output());
+    await pause();
+    expect(state.patches).toHaveLength(0);
+    const second = await fixture(async (_args, current) => {
+      current.targets = { recap: false, suggestion: false };
+      return output();
+    });
+    second.status('idle');
+    await vi.waitFor(() => expect(second.state.gets).toBe(2));
+    await pause();
+    expect(second.state.patches).toHaveLength(0);
+  });
+
+  it('ignores historical user updates but cancels a new request during generation', async () => {
+    let release;
+    const { state, runtime, status } = await fixture(() => new Promise((resolve) => { release = resolve; }));
+    status('idle');
+    await vi.waitFor(() => expect(state.calls).toHaveLength(1));
+    const userUpdate = (created) => runtime.processPayload({ type: 'message.updated', properties: {
+      info: { id: 'user', sessionID: 'session', role: 'user', time: { created } },
+    } });
+    userUpdate(1);
+    expect(state.calls[0].signal.aborted).toBe(false);
+    userUpdate(Date.now());
+    expect(state.calls[0].signal.aborted).toBe(true);
+    release(output());
+    await pause();
+    expect(state.patches).toHaveLength(0);
+  });
+
+  it('rejects endpoint changes before writing instead of carrying a session into a new runtime', async () => {
+    const warning = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const { state, status } = await fixture(async (_args, current) => {
+      current.base = 'http://unreachable.invalid';
+      return output();
+    });
+    status('idle');
+    await vi.waitFor(() => expect(warning).toHaveBeenCalled());
+    expect(state.patches).toHaveLength(0);
+    expect(state.gets).toBe(1);
+  });
+});

package/server/lib/walkthrough/DOCUMENTATION.md

@@ -86,11 +86,21 @@ its current hunk index while visible; regeneration remains user-initiated. The
 content-addressed cache continues to reuse an old review only when its hunks
 match, and otherwise reports stale anchors and uncovered current hunks.
 
-The panel offers the current branch's pull request on its own: it registers with
-the shared GitHub PR status store (`useGitHubPrStatusStore`) rather than waiting
-for the pull request panel to have been visited. That store already dedupes
-concurrent requests by signature and throttles by TTL, so several panels asking
-the same question produce one call to GitHub.
+PR mode uses the same searchable, paginated selector as Changes. Its list loads
+only while PR mode is visible. Selection ownership and handoff rules are in
+`packages/ui/src/stores/DOCUMENTATION.md`.
+
+PR sources may include `sourceRepo: { owner, repo }`. This qualifies both the
+GitHub request and the cache/job key as `pr:<owner>/<repo>:<number>`. Existing
+number-only sources retain `pr:<number>` and resolve the directory's repository.
+The PR panel forwards its resolved repository when opening walkthrough.
+
+`GET /api/walkthrough/pr-diff` accepts `directory` and a JSON `source` restricted
+to PRs. It returns GitHub's complete published diff as text, with no model
+readiness checks or generation. Successful empty patches return 200; auth,
+GitHub and malformed-response failures remain errors. Walkthrough generation
+keeps its existing empty-diff refusal. UI comparison behavior is documented in
+`packages/ui/src/components/views/DOCUMENTATION.md`.
 
 ## No truncation
 

package/server/lib/walkthrough/pr-source.test.js

@@ -0,0 +1,21 @@
+import { describe, expect, it } from 'vitest';
+import { parseSource, sourceKey, loadSourceSections } from './sources.js';
+
+describe('repository-qualified PR sources', () => {
+  it('keeps old cache keys and separates equal PR numbers in different repositories', () => {
+    expect(sourceKey(parseSource({ kind: 'pr', number: 42 }))).toBe('pr:42');
+    const upstream = parseSource({ kind: 'pr', number: 42, sourceRepo: { owner: 'upstream', repo: 'project' } });
+    const fork = parseSource({ kind: 'pr', number: 42, sourceRepo: { owner: 'fork', repo: 'project' } });
+    expect(sourceKey(upstream)).not.toBe(sourceKey(fork));
+  });
+
+  it('hands the selected repository to the walkthrough diff loader', async () => {
+    const source = parseSource({ kind: 'pr', number: 42, sourceRepo: { owner: 'upstream', repo: 'project' } });
+    let received;
+    await loadSourceSections('/repo', source, { getPullRequestDiff: async (...args) => {
+      received = args;
+      return { patch: 'published patch', meta: {} };
+    } });
+    expect(received).toEqual(['/repo', 42, source.sourceRepo]);
+  });
+});

package/server/lib/walkthrough/pull-request.js

@@ -1,4 +1,5 @@
 import { getOctokitOrNull } from '../github/octokit.js';
+import assert from 'node:assert/strict';
 import { resolveGitHubRepoFromDirectory } from '../github/repo/index.js';
 
 /**
@@ -8,7 +9,7 @@ import { resolveGitHubRepoFromDirectory } from '../github/repo/index.js';
  * three-dot semantics used for local branch reviews: work merged in from the
  * base branch is not part of it.
  */
-export async function getPullRequestDiff(directory, number) {
+export async function getPullRequestDiff(directory, number, sourceRepo, { allowEmpty = false } = {}) {
   const octokit = getOctokitOrNull();
   if (!octokit) {
     throw Object.assign(new Error('Connect a GitHub account to review pull requests'), {
@@ -19,7 +20,8 @@ export async function getPullRequestDiff(directory, number) {
 
   // The resolver returns `{ repo, remoteUrl }`, not the repo itself. Reading
   // `.owner` off the wrapper made this check fail for every repository.
-  const { repo } = await resolveGitHubRepoFromDirectory(directory);
+  const resolved = sourceRepo ? { repo: sourceRepo } : await resolveGitHubRepoFromDirectory(directory);
+  const { repo } = resolved;
   if (!repo?.owner || !repo?.repo) {
     throw Object.assign(new Error('This directory has no GitHub remote'), {
       statusCode: 400,
@@ -34,8 +36,9 @@ export async function getPullRequestDiff(directory, number) {
     headers: { accept: 'application/vnd.github.v3.diff' },
   });
 
-  const patch = typeof response?.data === 'string' ? response.data : '';
-  if (!patch.trim()) {
+  assert.match(response.data, /^(?:diff --git |\s*$)/, 'GitHub returned an invalid pull request diff');
+  const patch = response.data;
+  if (!allowEmpty && !patch.trim()) {
     throw Object.assign(new Error(`Pull request #${number} has no diff`), {
       statusCode: 404,
       code: 'empty-diff',

package/server/lib/walkthrough/pull-request.test.js

@@ -56,6 +56,22 @@ describe('getPullRequestDiff', () => {
     expect(request).not.toHaveBeenCalled();
   });
 
+  it('uses the selected upstream repository rather than the local fork', async () => {
+    const result = await getPullRequestDiff('/repo', 42, { owner: 'upstream', repo: 'project' });
+    expect(result.meta).toEqual({ owner: 'upstream', repo: 'project', number: 42 });
+    expect(resolveGitHubRepoFromDirectory).not.toHaveBeenCalled();
+    expect(request).toHaveBeenCalledWith('GET /repos/{owner}/{repo}/pulls/{pull_number}', {
+      owner: 'upstream', repo: 'project', pull_number: 42, headers: { accept: 'application/vnd.github.v3.diff' },
+    });
+  });
+
+  it('allows an empty comparison but rejects malformed GitHub bodies', async () => {
+    request.mockResolvedValue({ data: '' });
+    expect((await getPullRequestDiff('/repo', 42, undefined, { allowEmpty: true })).patch).toBe('');
+    request.mockResolvedValue({ data: { message: 'Not a diff' } });
+    await expect(getPullRequestDiff('/repo', 42)).rejects.toThrow();
+  });
+
   it('asks the user to connect GitHub before anything else', async () => {
     getOctokitOrNull.mockReturnValue(null);
 

package/server/lib/walkthrough/routes.js

@@ -1,3 +1,5 @@
+import { parseSource } from './sources.js';
+
 // `req.destroyed` is true for every healthy request once the body parser has
 // consumed the stream, so using it as a disconnect check silently swallows every
 // response. The response socket is the one that actually reflects whether the
@@ -51,6 +53,23 @@ export function registerWalkthroughRoutes(app, { getWalkthroughService }) {
     }
   });
 
+  // The comparison view needs the complete published patch, without model
+  // readiness checks, generated-file filtering, or local working-tree reads.
+  app.get('/api/walkthrough/pr-diff', async (req, res) => {
+    try {
+      const query = new URL(req.originalUrl, 'http://localhost').searchParams;
+      const directory = query.get('directory')?.trim() ?? '';
+      if (!directory) return res.status(400).json({ error: 'directory parameter is required' });
+      const source = parseSource(readSource(query.get('source')));
+      if (source.kind !== 'pr') return res.status(400).json({ error: 'A pull request source is required' });
+      const { getPullRequestDiff } = await getWalkthroughService();
+      const { patch } = await getPullRequestDiff(directory, source.number, source.sourceRepo, { allowEmpty: true });
+      res.type('text/plain').send(patch);
+    } catch (error) {
+      respondWithError(res, error, 'Failed to load pull request diff');
+    }
+  });
+
   // Deliberately not aborted when the client disconnects: generation runs for
   // minutes and a refresh must not throw the work away. Leaving detaches the
   // client; the job finishes and caches its result. Stopping is an explicit

package/server/lib/walkthrough/routes.test.js

@@ -18,6 +18,11 @@ describe('walkthrough routes', () => {
   let generateCalls = 0;
 
   const service = {
+    async getPullRequestDiff(directory, number, sourceRepo, options) {
+      lastArgs = { directory, number, sourceRepo, options };
+      if (number === 99) throw Object.assign(new Error('GitHub unavailable'), { statusCode: 503 });
+      return { patch: number === 1 ? '' : 'diff --git a/a.ts b/a.ts\n' };
+    },
     async getWalkthrough(args) {
       lastArgs = args;
       return { walkthrough: null, hunks: [], hunkCount: 0, generating: Boolean(job) };
@@ -84,6 +89,27 @@ describe('walkthrough routes', () => {
     expect(body.walkthrough).toEqual({ title: 'DONE' });
   });
 
+  it('serves the published PR snapshot with its repository, without generating', async () => {
+    const source = { kind: 'pr', number: 42, sourceRepo: { owner: 'upstream', repo: 'project' } };
+    const before = generateCalls;
+    const response = await fetch(`${base}/api/walkthrough/pr-diff?directory=/repo&source=${encodeURIComponent(JSON.stringify(source))}`);
+    expect(response.headers.get('content-type')).toContain('text/plain');
+    expect(await response.text()).toBe('diff --git a/a.ts b/a.ts\n');
+    expect(lastArgs).toEqual({ directory: '/repo', number: 42, sourceRepo: source.sourceRepo, options: { allowEmpty: true } });
+    expect(generateCalls).toBe(before);
+  });
+
+  it('distinguishes empty PRs, upstream failure, and invalid sources', async () => {
+    const request = (source) => fetch(`${base}/api/walkthrough/pr-diff?directory=/repo&source=${encodeURIComponent(JSON.stringify(source))}`);
+    const empty = await request({ kind: 'pr', number: 1 });
+    expect(empty.status).toBe(200);
+    expect(await empty.text()).toBe('');
+    expect((await request({ kind: 'pr', number: 99 })).status).toBe(503);
+    for (const source of [{ kind: 'pr', number: -1 }, { kind: 'branch', baseRef: 'main', headRef: 'feature' }, { kind: 'pr', number: 1, sourceRepo: { owner: '../bad', repo: 'repo' } }]) {
+      expect((await request(source)).status).toBe(400);
+    }
+  });
+
   it('delivers the result to a client that reconnected after a refresh', async () => {
     const controller = new AbortController();
     const seen = generateCalls;

package/server/lib/walkthrough/sources.js

@@ -1,4 +1,5 @@
 import { getDiff, getRangeDiff, getCommitDiff, getUntrackedDiffs, listUntrackedPaths } from '../git/service.js';
+import assert from 'node:assert/strict';
 
 // A walkthrough source resolves to one or more diff *sections*. A section is a
 // patch plus the scope its hunk ids live in; keeping staged and working-tree
@@ -45,6 +46,16 @@ export function parseSource(raw) {
     if (!Number.isInteger(number) || number <= 0) {
       throw new WalkthroughSourceError('pr sources require a positive number');
     }
+    if (raw.sourceRepo !== undefined) {
+      const { owner, repo } = raw.sourceRepo ?? {};
+      try {
+        assert.match(owner, /^[a-zA-Z0-9-]+$/);
+        assert.match(repo, /^[a-zA-Z0-9_.-]+$/);
+      } catch {
+        throw new WalkthroughSourceError('pr sources require a valid repository');
+      }
+      return { kind: 'pr', number, sourceRepo: { owner, repo } };
+    }
     return { kind: 'pr', number };
   }
 
@@ -71,7 +82,7 @@ export function sourceKey(source) {
   if (source.kind === 'working-tree') return `working-tree:${source.scope}`;
   if (source.kind === 'branch') return `branch:${source.baseRef}...${source.headRef}`;
   if (source.kind === 'commit') return `commit:${source.hash}`;
-  return `pr:${source.number}`;
+  return source.sourceRepo ? `pr:${source.sourceRepo.owner}/${source.sourceRepo.repo}:${source.number}` : `pr:${source.number}`;
 }
 
 // `git diff` never reports untracked files, so a brand-new file would be
@@ -129,7 +140,7 @@ export async function loadSourceSections(directory, source, { getPullRequestDiff
     throw new WalkthroughSourceError('Pull request diffs are unavailable', 500);
   }
 
-  const { patch, meta } = await getPullRequestDiff(directory, source.number);
+  const { patch, meta } = await getPullRequestDiff(directory, source.number, source.sourceRepo);
   return {
     sections: patch && patch.trim() ? [{ scope: `pr:${source.number}`, patch }] : [],
     meta: meta || {},

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

@@ -0,0 +1,130 @@
+import { afterEach, describe, expect, it } from 'vitest';
+import express from 'express';
+import path from 'node:path';
+import { registerOpenCodeProxy } from './lib/opencode/proxy.js';
+
+const servers = [];
+const listen = async (app) => {
+  const server = await new Promise((resolve) => {
+    const listening = app.listen(0, '127.0.0.1', () => resolve(listening));
+  });
+  servers.push(server);
+  return `http://127.0.0.1:${server.address().port}`;
+};
+
+afterEach(async () => {
+  await Promise.all(servers.splice(0).map((server) => new Promise((resolve) => {
+    server.closeAllConnections();
+    server.close(resolve);
+  })));
+});
+
+const worktree = '/repo/worktree with spaces';
+const projectConfig = { mcp: { projectOnly: { type: 'local', command: ['test-mcp'], enabled: false } } };
+
+async function createFixture({ timeoutMs = 1000 } = {}) {
+  let bootstrap = { status: 'pending', phase: 'directory-created', error: null };
+  let instance;
+  const forwarded = [];
+  const probed = [];
+  const upstream = express();
+  upstream.use(express.json());
+  upstream.use((req, res) => {
+    forwarded.push(req.path);
+    // Model OpenCode's instance cache: even a GET can permanently capture the
+    // empty directory, and a later session inherits that project's identity.
+    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') {
+      return res.json({ projectID: instance.projectID, directory: req.query.directory, title: req.body.title });
+    }
+    res.json([]);
+  });
+  const upstreamUrl = await listen(upstream);
+  const app = express();
+  app.use(express.json());
+  registerOpenCodeProxy(app, {
+    fs: {}, os: {}, path,
+    OPEN_CODE_READY_GRACE_MS: 0,
+    WORKTREE_READY_TIMEOUT_MS: timeoutMs,
+    getRuntime: () => ({ openCodePort: new URL(upstreamUrl).port, isOpenCodeReady: true }),
+    getOpenCodeAuthHeaders: () => ({}),
+    buildOpenCodeUrl: (requestPath) => `${upstreamUrl}${requestPath}`,
+    ensureOpenCodeApiPrefix: () => {},
+    readWorktreeBootstrapStatus: async (directory) => {
+      probed.push(directory);
+      return directory === worktree ? bootstrap : { status: 'ready', phase: 'setup-ready' };
+    },
+  });
+  return {
+    url: await listen(app), forwarded, probed,
+    setBootstrap: (next) => { bootstrap = next; },
+  };
+}
+
+describe('issue #3464 worktree OpenCode initialization', () => {
+  it('holds config and session creation until Git is ready, while setup remains pending', async () => {
+    const fixture = await createFixture();
+    const config = fetch(`${fixture.url}/api/config?directory=${encodeURIComponent(worktree)}`);
+    const session = fetch(`${fixture.url}/api/session?directory=${encodeURIComponent(worktree)}`, {
+      method: 'POST', headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ title: 'First worktree session' }),
+    });
+    await expect.poll(() => fixture.probed.length).toBeGreaterThanOrEqual(2);
+    expect(fixture.forwarded).toEqual([]);
+    fixture.setBootstrap({ status: 'pending', phase: 'git-ready', error: null });
+    expect(await (await config).json()).toEqual(projectConfig);
+    expect(await (await session).json()).toEqual({
+      projectID: 'project-3464', directory: worktree, title: 'First worktree session',
+    });
+  });
+
+  it('gates encoded directory headers and the separately forwarded session list', async () => {
+    const fixture = await createFixture();
+    const response = fetch(`${fixture.url}/api/session`, { headers: {
+      'x-opencode-directory': encodeURIComponent(worktree), 'x-opencode-directory-encoding': 'uri',
+    } });
+    await expect.poll(() => fixture.probed.length).toBeGreaterThan(0);
+    expect(fixture.probed[0]).toBe(worktree);
+    expect(fixture.forwarded).toEqual([]);
+    fixture.setBootstrap({ status: 'ready', phase: 'setup-ready', error: null });
+    expect((await response).status).toBe(200);
+    expect(fixture.forwarded).toEqual(['/session']);
+  });
+
+  it('does not block unrelated directories while a worktree is pending', async () => {
+    const fixture = await createFixture();
+    expect((await fetch(`${fixture.url}/api/session?directory=/other-project`)).status).toBe(200);
+    expect(fixture.probed).toEqual(['/other-project']);
+  });
+
+  it('does not forward an abandoned request when checkout later finishes', async () => {
+    const fixture = await createFixture();
+    const controller = new AbortController();
+    const response = fetch(`${fixture.url}/api/config?directory=${encodeURIComponent(worktree)}`, {
+      signal: controller.signal,
+    });
+    const rejected = expect(response).rejects.toThrow();
+    await expect.poll(() => fixture.probed.length).toBeGreaterThan(0);
+    controller.abort();
+    await rejected;
+    // Allow the server to observe the closed client before releasing checkout.
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    fixture.setBootstrap({ status: 'ready', phase: 'setup-ready', error: null });
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    expect(fixture.forwarded).toEqual([]);
+  });
+
+  it('fails closed on bootstrap failure or timeout without initializing OpenCode', async () => {
+    const fixture = await createFixture({ timeoutMs: 0 });
+    const timedOut = await fetch(`${fixture.url}/api/config?directory=${encodeURIComponent(worktree)}`);
+    expect(timedOut.status).toBe(503);
+    fixture.setBootstrap({ status: 'failed', phase: 'directory-created', error: 'checkout failed' });
+    const failed = await fetch(`${fixture.url}/api/session?directory=${encodeURIComponent(worktree)}`, { method: 'POST' });
+    expect(failed.status).toBe(503);
+    expect(await failed.json()).toEqual({ error: 'checkout failed' });
+    expect(fixture.forwarded).toEqual([]);
+  });
+});