fix(worktree): gate sessions on bootstrap readiness

packages/ui/src/components/session/NewWorktreeDialog.tsx

@@ -33,6 +33,7 @@ import * as sessionActions from '@/sync/session-actions';
 import { useConfigStore } from '@/stores/useConfigStore';
 import { validateWorktreeCreate, createWorktree } from '@/lib/worktrees/worktreeManager';
 import { withWorktreeUpstreamDefaults } from '@/lib/worktrees/worktreeCreate';
+import { waitForWorktreeBootstrap } from '@/lib/worktrees/worktreeBootstrap';
 import { getWorktreeSetupCommands } from '@/lib/openchamberConfig';
 import { getRootBranch } from '@/lib/worktrees/worktreeStatus';
 import { generateBranchSlug } from '@/lib/git/branchNameGenerator';
@@ -856,6 +857,8 @@ export function NewWorktreeDialog({
       let createdSessionId: string | null = null;
 
       if (shouldCreateSession) {
+        await waitForWorktreeBootstrap(metadata.path);
+
         const sessionTitle = linkedIssue
           ? `#${linkedIssue.number} ${linkedIssue.title}`.trim()
           : linkedPrState

packages/ui/src/lib/worktreeSessionCreator.ts

@@ -25,6 +25,7 @@ import {
   rejectPendingDraftWorktreeRequest,
   resolvePendingDraftWorktreeRequest,
 } from '@/lib/worktrees/pendingDraftWorktree';
+import { waitForWorktreeBootstrap } from '@/lib/worktrees/worktreeBootstrap';
 
 const normalizePath = (value: string): string => value.replace(/\\/g, '/').replace(/\/+$/, '') || value;
 
@@ -417,6 +418,8 @@ export async function createWorktreeSessionForBranch(
       kind,
     };
 
+    await waitForWorktreeBootstrap(metadata.path);
+
     // Create the session
     const sessionStore = useSessionUIStore.getState();
     const session = await sessionStore.createSession(undefined, metadata.path);
@@ -520,6 +523,8 @@ export async function createWorktreeSessionForNewBranch(
         kind,
       };
 
+      await waitForWorktreeBootstrap(metadata.path);
+
       const sessionStore = useSessionUIStore.getState();
       const session = await sessionStore.createSession(undefined, metadata.path);
       if (!session) {

packages/ui/src/stores/useMultiRunStore.test.ts

@@ -6,6 +6,8 @@ const registeredDirectories: Array<{ sessionID: string; directory: string }> = [
 const ensureChildCalls: Array<{ directory: string; bootstrap?: boolean }> = [];
 const worktreeMetadataCalls: Array<{ sessionId: string; path: string }> = [];
 const worktreeCreateCalls: Array<{ project: { id?: string; path: string }; args: Record<string, unknown>; options: unknown }> = [];
+const worktreeBootstrapWaitCalls: string[] = [];
+const operationOrder: string[] = [];
 let isGitRepository = false;
 const createWorktreeWithDefaultsMock = mock((project: { id?: string; path: string }, args: Record<string, unknown>, options: unknown) => {
   worktreeCreateCalls.push({ project, args, options });
@@ -52,12 +54,15 @@ mock.module('@/lib/opencode/client', () => ({
         currentDirectory = previous;
       }
     },
-    createSession: async (params?: { title?: string }): Promise<Session> => ({
-      id: 'ses_multirun',
-      title: params?.title ?? '',
-      directory: currentDirectory,
-      time: { created: 1, updated: 1 },
-    } as Session),
+    createSession: async (params?: { title?: string }): Promise<Session> => {
+      operationOrder.push(`createSession:${currentDirectory}`);
+      return {
+        id: 'ses_multirun',
+        title: params?.title ?? '',
+        directory: currentDirectory,
+        time: { created: 1, updated: 1 },
+      } as Session;
+    },
   },
 }));
 
@@ -70,6 +75,14 @@ mock.module('@/lib/worktrees/worktreeCreate', () => ({
   resolveRootTrackingRemote: mock(() => Promise.resolve(null)),
 }));
 
+mock.module('@/lib/worktrees/worktreeBootstrap', () => ({
+  waitForWorktreeBootstrap: (directory: string) => {
+    worktreeBootstrapWaitCalls.push(directory);
+    operationOrder.push(`wait:${directory}`);
+    return Promise.resolve();
+  },
+}));
+
 mock.module('@/lib/worktrees/worktreeStatus', () => ({
   getRootBranch: mock(() => Promise.resolve('main')),
 }));
@@ -139,6 +152,8 @@ describe('useMultiRunStore', () => {
     ensureChildCalls.length = 0;
     worktreeMetadataCalls.length = 0;
     worktreeCreateCalls.length = 0;
+    worktreeBootstrapWaitCalls.length = 0;
+    operationOrder.length = 0;
     isGitRepository = false;
     childState.session = [];
     childState.sessionTotal = 0;
@@ -181,6 +196,11 @@ describe('useMultiRunStore', () => {
     expect(worktreeCreateCalls[0]?.project).toEqual({ id: 'project-1', path: '/repo' });
     expect(worktreeCreateCalls[0]?.args.returnAfterDirectoryCreated).toBe(true);
     expect(worktreeCreateCalls[0]?.options).toEqual({ resolvedRootTrackingRemote: null });
+    expect(worktreeBootstrapWaitCalls).toEqual(['/repo-worktrees/fix-thing']);
+    expect(operationOrder).toEqual([
+      'wait:/repo-worktrees/fix-thing',
+      'createSession:/repo-worktrees/fix-thing',
+    ]);
     expect(registeredDirectories).toEqual([{ sessionID: 'ses_multirun', directory: '/repo-worktrees/fix-thing' }]);
     expect(worktreeMetadataCalls).toEqual([{ sessionId: 'ses_multirun', path: '/repo-worktrees/fix-thing' }]);
   });

packages/ui/src/stores/useMultiRunStore.ts

@@ -7,6 +7,7 @@ import { opencodeClient } from '@/lib/opencode/client';
 import { saveWorktreeSetupCommands } from '@/lib/openchamberConfig';
 import type { ProjectRef } from '@/lib/worktrees/worktreeManager';
 import { createWorktreeWithDefaults, resolveRootTrackingRemote } from '@/lib/worktrees/worktreeCreate';
+import { waitForWorktreeBootstrap } from '@/lib/worktrees/worktreeBootstrap';
 import { getRootBranch } from '@/lib/worktrees/worktreeStatus';
 import { checkIsGitRepository } from '@/lib/gitApi';
 import { useDirectoryStore } from './useDirectoryStore';
@@ -244,6 +245,8 @@ export const useMultiRunStore = create<MultiRunStore>()(
                   kind: 'standard' as const,
                 };
 
+                await waitForWorktreeBootstrap(worktreeMetadata.path);
+
                 const session = await opencodeClient.withDirectory(
                   worktreeMetadata.path,
                   () => opencodeClient.createSession({ title: sessionTitle }),

packages/ui/src/sync/session-ui-store.ts

@@ -29,6 +29,7 @@ import { markPendingUserSendAnimation } from "@/lib/userSendAnimation"
 import { flattenAssistantTextParts } from "@/lib/messages/messageText"
 import { composeForkSessionMessage } from "@/lib/messages/executionMeta"
 import { waitForPendingDraftWorktreeRequest } from "@/lib/worktrees/pendingDraftWorktree"
+import { waitForWorktreeBootstrap } from "@/lib/worktrees/worktreeBootstrap"
 import { resolveProjectForSessionDirectory } from "@/lib/projectResolution"
 import {
   getSyncSessions,
@@ -401,6 +402,84 @@ const writeRuntimeSessionMemory = (key: string, patch: Partial<RuntimeSessionMem
   })
 }
 
+type MaterializedDraftSession = {
+  sessionId: string
+  directory: string | null
+  agent?: string
+  syntheticParts?: SyntheticContextPart[]
+}
+
+export async function materializeOpenDraftSession(selection: {
+  providerID: string
+  modelID: string
+  agent?: string
+  variant?: string
+}): Promise<MaterializedDraftSession | null> {
+  const store = useSessionUIStore.getState()
+  const draft = store.newSessionDraft
+  if (!draft?.open) return null
+
+  const trimmedAgent = typeof selection.agent === "string" && selection.agent.trim().length > 0
+    ? selection.agent.trim()
+    : undefined
+  const draftTargetFolderId = draft.targetFolderId
+  let draftDirectoryOverride = draft.bootstrapPendingDirectory ?? draft.directoryOverride ?? null
+  const draftProjectId = draft.selectedProjectId ?? null
+
+  if (draft.pendingWorktreeRequestId) {
+    draftDirectoryOverride = await waitForPendingDraftWorktreeRequest(draft.pendingWorktreeRequestId)
+    store.resolvePendingDraftWorktreeTarget(draft.pendingWorktreeRequestId, draftDirectoryOverride)
+  }
+
+  if (draftDirectoryOverride) {
+    await waitForWorktreeBootstrap(draftDirectoryOverride)
+  }
+
+  const created = await store.createSession(draft.title, draftDirectoryOverride, draft.parentID ?? null)
+  if (!created?.id) throw new Error("Failed to create session")
+
+  persistDraftTarget({
+    projectId: draftProjectId,
+    directory: normalizePath(draftDirectoryOverride ?? created.directory ?? null),
+  })
+
+  const draftSyntheticParts = draft.syntheticParts
+  const createdDirectory = normalizePath(draftDirectoryOverride ?? created.directory ?? null)
+  const configState = useConfigStore.getState()
+  void activateConfigForDirectory(createdDirectory).catch((error) => {
+    console.warn("Failed to activate directory after creating session:", error)
+  })
+
+  const effectiveDraftAgent = trimmedAgent ?? configState.currentAgentName
+
+  useSelectionStore.getState().saveSessionModelSelection(created.id, selection.providerID, selection.modelID)
+
+  if (effectiveDraftAgent) {
+    useSelectionStore.getState().saveSessionAgentSelection(created.id, effectiveDraftAgent)
+    useSelectionStore.getState().saveAgentModelForSession(created.id, effectiveDraftAgent, selection.providerID, selection.modelID)
+    useSelectionStore.getState().saveAgentModelVariantForSession(created.id, effectiveDraftAgent, selection.providerID, selection.modelID, selection.variant)
+  }
+
+  store.initializeNewOpenChamberSession(created.id, configState.agents ?? [])
+
+  store.closeNewSessionDraft()
+  store.setCurrentSession(created.id, createdDirectory)
+
+  if (draftTargetFolderId) {
+    const scopeKey = draftDirectoryOverride || created.directory || null
+    if (scopeKey) {
+      useSessionFoldersStore.getState().addSessionToFolder(scopeKey, draftTargetFolderId, created.id)
+    }
+  }
+
+  return {
+    sessionId: created.id,
+    directory: createdDirectory,
+    agent: effectiveDraftAgent,
+    syntheticParts: draftSyntheticParts,
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Store
 // ---------------------------------------------------------------------------
@@ -913,59 +992,21 @@ export const useSessionUIStore = create<SessionUIState>()((set, get) => ({
 
     // ---- New session from draft ----
     if (!options?.sessionId && draft?.open) {
-      const draftTargetFolderId = draft.targetFolderId
-      let draftDirectoryOverride = draft.bootstrapPendingDirectory ?? draft.directoryOverride ?? null
-      const draftProjectId = draft.selectedProjectId ?? null
-
-      if (draft.pendingWorktreeRequestId) {
-        draftDirectoryOverride = await waitForPendingDraftWorktreeRequest(draft.pendingWorktreeRequestId)
-        get().resolvePendingDraftWorktreeTarget(draft.pendingWorktreeRequestId, draftDirectoryOverride)
-      }
-
-      const created = await get().createSession(draft.title, draftDirectoryOverride, draft.parentID ?? null)
-      if (!created?.id) throw new Error("Failed to create session")
-
-      persistDraftTarget({
-        projectId: draftProjectId,
-        directory: normalizePath(draftDirectoryOverride ?? created.directory ?? null),
-      })
-
-      const draftSyntheticParts = draft.syntheticParts
-      const createdDirectory = normalizePath(draftDirectoryOverride ?? created.directory ?? null)
-      const configState = useConfigStore.getState()
-      void activateConfigForDirectory(createdDirectory).catch((error) => {
-        console.warn("Failed to activate directory after creating session:", error)
+      const createdDraftSession = await materializeOpenDraftSession({
+        providerID,
+        modelID,
+        agent: trimmedAgent,
+        variant,
       })
+      if (!createdDraftSession) throw new Error("Failed to create session")
 
-      const effectiveDraftAgent = trimmedAgent ?? configState.currentAgentName
-
-      useSelectionStore.getState().saveSessionModelSelection(created.id, providerID, modelID)
-
-      if (effectiveDraftAgent) {
-        useSelectionStore.getState().saveSessionAgentSelection(created.id, effectiveDraftAgent)
-        useSelectionStore.getState().saveAgentModelForSession(created.id, effectiveDraftAgent, providerID, modelID)
-        useSelectionStore.getState().saveAgentModelVariantForSession(created.id, effectiveDraftAgent, providerID, modelID, variant)
-      }
-
-      get().initializeNewOpenChamberSession(created.id, configState.agents ?? [])
-
-      get().closeNewSessionDraft()
-      get().setCurrentSession(created.id, createdDirectory)
-
-      if (draftTargetFolderId) {
-        const scopeKey = draftDirectoryOverride || created.directory || null
-        if (scopeKey) {
-          useSessionFoldersStore.getState().addSessionToFolder(scopeKey, draftTargetFolderId, created.id)
-        }
-      }
-
-      const mergedAdditionalParts = draftSyntheticParts?.length
-        ? [...(additionalParts || []), ...draftSyntheticParts]
+      const mergedAdditionalParts = createdDraftSession.syntheticParts?.length
+        ? [...(additionalParts || []), ...createdDraftSession.syntheticParts]
         : additionalParts
 
-      notifyMessageSent(created.id)
+      notifyMessageSent(createdDraftSession.sessionId)
 
-      markPendingUserSendAnimation(created.id)
+      markPendingUserSendAnimation(createdDraftSession.sessionId)
 
       const files = attachments?.map((a) => ({
         type: "file" as const,
@@ -975,12 +1016,12 @@ export const useSessionUIStore = create<SessionUIState>()((set, get) => ({
       }))
 
       await routeMessage({
-        sessionId: created.id,
-        directory: createdDirectory,
+        sessionId: createdDraftSession.sessionId,
+        directory: createdDraftSession.directory,
         content,
         providerID,
         modelID,
-        agent: effectiveDraftAgent,
+        agent: createdDraftSession.agent,
         agentMentionName,
         variant,
         inputMode,
@@ -1333,6 +1374,10 @@ export const useSessionUIStore = create<SessionUIState>()((set, get) => ({
         returnAfterDirectoryCreated: true,
       })
       sessionDirectory = normalizePath(createdWorktree.path)
+      if (!sessionDirectory) {
+        throw new Error("Worktree create missing name/path")
+      }
+      await waitForWorktreeBootstrap(sessionDirectory)
     }
 
     const session = await get().createSession(undefined, sessionDirectory || null, null)

packages/vscode/src/gitService.ts

@@ -1754,6 +1754,19 @@ export async function validateWorktreeCreate(directory: string, input: CreateGit
   }
 }
 
+const assertWorktreeCreatePreflight = async (directory: string, input: CreateGitWorktreePayload = {}): Promise<void> => {
+  const validation = await validateWorktreeCreate(directory, input);
+  if (validation?.ok) {
+    return;
+  }
+
+  const message = validation?.errors
+    ?.map((error) => error?.message)
+    .filter(Boolean)
+    .join('\n') || 'Failed to validate worktree creation';
+  throw new Error(message);
+};
+
 export async function previewWorktreeCreate(directory: string, input: CreateGitWorktreePayload = {}): Promise<GitWorktreeInfo> {
   const mode = input?.mode === 'existing' ? 'existing' : 'new';
   const context = await resolveWorktreeProjectContext(directory);
@@ -1907,6 +1920,11 @@ async function attachGitWorktreeToCandidate(
 export async function createWorktree(directory: string, input: CreateGitWorktreePayload = {}): Promise<GitWorktreeInfo> {
   const mode = input?.mode === 'existing' ? 'existing' : 'new';
   const context = await resolveWorktreeProjectContext(directory);
+
+  if (input?.returnAfterDirectoryCreated === true) {
+    await assertWorktreeCreatePreflight(directory, input);
+  }
+
   await fs.promises.mkdir(context.worktreeRoot, { recursive: true });
 
   const preferredName = String(input?.worktreeName || input?.name || '').trim();

packages/web/server/lib/git/service.js

@@ -3544,6 +3544,19 @@ export async function validateWorktreeCreate(directory, input = {}) {
   }
 }
 
+const assertWorktreeCreatePreflight = async (directory, input = {}) => {
+  const validation = await validateWorktreeCreate(directory, input);
+  if (validation?.ok) {
+    return;
+  }
+
+  const message = validation?.errors
+    ?.map((error) => error?.message)
+    .filter(Boolean)
+    .join('\n') || 'Failed to validate worktree creation';
+  throw new Error(message);
+};
+
 export async function previewWorktreeCreate(directory, input = {}) {
   const mode = input?.mode === 'existing' ? 'existing' : 'new';
   const context = await resolveWorktreeProjectContext(directory);
@@ -3692,6 +3705,11 @@ async function attachGitWorktreeToCandidate(context, candidate, input = {}) {
 export async function createWorktree(directory, input = {}) {
   const mode = input?.mode === 'existing' ? 'existing' : 'new';
   const context = await resolveWorktreeProjectContext(directory);
+
+  if (input?.returnAfterDirectoryCreated === true) {
+    await assertWorktreeCreatePreflight(directory, input);
+  }
+
   await fsp.mkdir(context.worktreeRoot, { recursive: true });
 
   const preferredName = String(input?.worktreeName || input?.name || '').trim();