import type * as RuntimeWorktreeCreateGit from './runtime-worktree-create-git' import { labelOnlyCreateRequests, renameCreatedWorktreeOnFirstWork } from '../worktree-create-first-work-test-harness' import { isAutoGeneratedCreatureBranchName } from '../../shared/branch-name-from-work' import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest' import { resolve } from 'node:path' import type { Repo } from '../../shared/repo-types' import { getDefaultRepoHookSettings } from '../../shared/constants' import type { AddWorktreeOptions } from '../git/worktree' import { acquireGitAdmission, GitAdmissionScheduler, _resetGitAdmissionForTests } from '../git/command-runner/git-subprocess-admission' const { runtimeCreateMocks: mocks, worktreePath, pickedBranch, writtenMeta, readSparsePresets, createWorktree, resetRuntimeCreateMocks } = await vi.hoisted(async () => await import('./runtime-local-worktree-create-test-harness')) vi.mock('../text-generation/commit-message-text-generation', () => ({ resolveTextGenerationParams: () => ({ ok: true, params: { agentId: 'claude', model: 'fixture' } }), generateBranchNameFromContext: async () => ({ success: true, slug: 'fix-auth' }) })) vi.mock('../text-generation/commit-message-agent-environment', () => ({ prepareLocalCommitMessageAgentEnv: async () => ({ ok: true }) })) vi.mock('../git/runner', () => ({ gitExecFileAsync: mocks.git })) vi.mock('../project-runtime-git-options', () => ({ getLocalProjectGitExecOptions: () => ({ cwd: '/repo', ...mocks.routing() }), getLocalProjectWorktreeGitOptions: mocks.routing, getWorktreeMirrorDistro: () => undefined })) vi.mock('../git/repo', () => ({ getBaseRefDefault: mocks.defaultBase, resolveDefaultBaseRefWithLocalGit: mocks.defaultBase, getBranchConflictKind: mocks.branchConflict })) vi.mock('../git/git-username', () => ({ resolveLocalGitUsername: async () => '' })) vi.mock('../hooks', () => ({ getEffectiveHooks: mocks.effectiveHooks })) vi.mock('../git/worktree-base-ref-probe', () => ({ hasLocalWorktreeBaseRef: mocks.hasBase })) vi.mock('./runtime-worktree-create-git', () => ({ resolveCreateBranchName: mocks.branchName, canCheckoutExistingLocalBranch: mocks.canCheckout, getLocalGitHubPrForBranch: mocks.githubPr, getSelectedHostedReviewForBranch: vi.fn() })) vi.mock('./runtime-worktree-filesystem', () => ({ runtimePathExists: mocks.pathExists })) vi.mock('../worktree-create-preparation', () => ({ consumePreparedWorktreeCreate: mocks.consume })) vi.mock('../git/worktree', () => ({ addWorktree: mocks.add, addSparseWorktree: mocks.addSparse })) vi.mock('../ipc/worktree-remote', () => ({ configureCreatedWorktreePushTarget: mocks.pushTarget })) vi.mock('../ipc/created-worktree-reconciliation', () => ({ resolveCreatedWorktree: mocks.listing })) vi.mock('../worktree-name-retirement', () => ({ failedWorktreeCreationNeedsRetirement: vi.fn(), retireGeneratedWorktreeName: vi.fn() })) vi.mock('../git/worktree-shared-directories', () => ({ resolveWorktreeSharedDirectories: mocks.resolveShared })) vi.mock('../git/worktree-include-file', () => ({ resolveWorktreeIncludePaths: mocks.resolveInclude })) vi.mock('../ipc/worktree-symlinks', () => ({ createWorktreeCopiedPaths: mocks.copyPaths, createWorktreeLinkedPaths: vi.fn(), createWorktreeSharedPaths: vi.fn() })) import { WorktreeCreateSetupChoiceRefusedError } from './worktree-create-setup-choice-refusal' import type { PreparationRearmHolder } from '../worktree-create-preparation' import { createWorktreeCreateTimingRecorder } from '../worktree-create-timing' import { withoutInFlightWorktreeCreates } from '../worktree-create-in-flight' beforeEach(resetRuntimeCreateMocks) describe('runtime create listing hold', () => { const rows = [{ path: worktreePath }] it('holds the checkout during Git creation and releases it once metadata is saved', async () => { mocks.consume.mockImplementation(async () => { expect(withoutInFlightWorktreeCreates('repo-1', rows)).toEqual([]) return { status: 'hit', result: {}, rearm: mocks.rearm } }) mocks.resolveShared.mockImplementation(async () => { expect(withoutInFlightWorktreeCreates('repo-1', rows)).toBe(rows) return [] }) await createWorktree() expect(mocks.resolveShared).toHaveBeenCalledOnce() }) it('releases the checkout when Git creation fails', async () => { mocks.consume.mockRejectedValue(new Error('checkout failed')) await expect(createWorktree()).rejects.toThrow('checkout failed') expect(withoutInFlightWorktreeCreates('repo-1', rows)).toBe(rows) }) }) describe('runtime nested-workspaces layout', () => { const addedPath = (): string => String(mocks.add.mock.calls[0]?.[1]) it('honors the client choice over the host default', async () => { mocks.consume.mockResolvedValue({ status: 'miss', reason: 'disabled', rearm: mocks.rearm }) await createWorktree({ nestWorkspaces: true }) expect(addedPath()).toBe(resolve('/worktrees', 'repo', 'app')) }) it('falls back to the host setting when the client sends none', async () => { mocks.consume.mockResolvedValue({ status: 'miss', reason: 'disabled', rearm: mocks.rearm }) await createWorktree({}) expect(addedPath()).toBe(worktreePath) }) }) describe('runtime keep-local-main-up-to-date choice', () => { const addRefreshArg = (): unknown => mocks.add.mock.calls[0]?.[4] const addOptions = (): AddWorktreeOptions | undefined => mocks.add.mock.calls[0]?.[6] beforeEach(() => { mocks.consume.mockResolvedValue({ status: 'miss', reason: 'disabled', rearm: mocks.rearm }) mocks.remoteBase.mockResolvedValue({ remote: 'origin', branch: 'main', ref: 'refs/remotes/origin/main', base: 'origin/main' }) }) it('refreshes local main when the client turned it on, over the host default', async () => { await createWorktree({ refreshLocalBaseRefOnWorktreeCreate: true }) expect(mocks.consume).toHaveBeenCalledWith( expect.objectContaining({ refreshLocalBaseRef: true }) ) expect(addRefreshArg()).toBe(true) expect(addOptions()?.suggestLocalBaseRefUpdate).toBeUndefined() }) it('suppresses the suggestion the client already dismissed', async () => { await createWorktree({ localBaseRefSuggestionDismissed: true }) expect(addRefreshArg()).toBe(false) expect(addOptions()?.suggestLocalBaseRefUpdate).toBeUndefined() }) it('keeps the host setting and suggestion when the client sends neither', async () => { await createWorktree({}) expect(addRefreshArg()).toBe(false) expect(addOptions()?.suggestLocalBaseRefUpdate).toBe(true) }) }) describe('runtime prepared-worktree replenishment', () => { it('keeps a failed claim reserved through the normal-add fallback', async () => { mocks.consume.mockResolvedValue({ status: 'miss', reason: 'finalize_failed', rearm: mocks.rearm }) const rearm: PreparationRearmHolder = { fire: () => {} } await createWorktree({}, rearm) expect(mocks.add).toHaveBeenCalledOnce() expect(mocks.rearm).not.toHaveBeenCalled() rearm.fire() expect(mocks.rearm).toHaveBeenCalledOnce() }) it('keeps the failed claim release available when the fallback also fails', async () => { mocks.consume.mockResolvedValue({ status: 'miss', reason: 'prepare_failed', rearm: mocks.rearm }) mocks.add.mockRejectedValue(new Error('normal add failed')) const rearm: PreparationRearmHolder = { fire: () => {} } await expect(createWorktree({}, rearm)).rejects.toThrow('normal add failed') expect(mocks.rearm).not.toHaveBeenCalled() rearm.fire() expect(mocks.rearm).toHaveBeenCalledOnce() }) it('leaves the re-arm holder armed but unfired once probes and include copies finish', async () => { const rearm: PreparationRearmHolder = { fire: () => {} } let finishProbe!: (paths: string[]) => void mocks.resolveShared.mockImplementation( () => new Promise((resolve) => { finishProbe = resolve }) ) let finishCopy!: (paths: string[]) => void mocks.copyPaths.mockImplementation( () => new Promise((resolve) => { finishCopy = resolve }) ) const creation = createWorktree({}, rearm) await vi.waitFor(() => expect(mocks.resolveShared).toHaveBeenCalledOnce()) expect(mocks.rearm).not.toHaveBeenCalled() finishProbe([]) await vi.waitFor(() => expect(mocks.copyPaths).toHaveBeenCalledOnce()) expect(mocks.rearm).not.toHaveBeenCalled() finishCopy([]) await creation // The caller launches terminals before arming, so create must not fire it itself. expect(mocks.rearm).not.toHaveBeenCalled() rearm.fire() expect(mocks.rearm).toHaveBeenCalledOnce() }) it('arms the holder even when materialization fails', async () => { mocks.copyPaths.mockRejectedValue(new Error('copy failed')) const rearm: PreparationRearmHolder = { fire: () => {} } await expect(createWorktree({}, rearm)).rejects.toThrow('copy failed') // The slot was consumed before the failure, so the caller's `finally` must find a real thunk. rearm.fire() expect(mocks.rearm).toHaveBeenCalledOnce() }) }) describe('runtime create timing', () => { it('times the add with the prepared-checkout consume inside it, and lists the worktrees', async () => { mocks.listing.mockResolvedValue({ created: mocks.created, worktrees: [mocks.created, mocks.created, mocks.created], listingComplete: true }) const timing = createWorktreeCreateTimingRecorder() mocks.branchName.mockResolvedValue('main') await createWorktree(pickedBranch, undefined, timing) expect(mocks.consume).toHaveBeenCalledWith( expect.objectContaining({ timing, branch: 'main', baseBranch: 'origin/main' }) ) expect(mocks.add).not.toHaveBeenCalled() expect(mocks.consume.mock.calls[0][0].options).toEqual({}) const finished = timing.finish() expect(finished.phases.map((phase) => phase.phase)).toEqual( expect.arrayContaining([ 'resolve_name', 'git_worktree_add', 'list_created_worktree', 'persist_metadata', 'copy_worktreeinclude' ]) ) expect(finished).toMatchObject({ executionHost: 'local', worktreeCount: 3 }) }) it('records a sparse create as a miss without consulting the prepared checkout', async () => { const timing = createWorktreeCreateTimingRecorder() await createWorktree({ sparseCheckout: { directories: ['src'] } }, undefined, timing) expect(mocks.consume).not.toHaveBeenCalled() expect(timing.finish().preparedCheckout).toEqual({ status: 'miss', reason: 'sparse_checkout' }) }) }) describe('runtime create Git priority', () => { it.each([undefined, 'Ubuntu'])( 'preserves interactive priority and routing on %s', async (wslDistro) => { const routing = wslDistro ? { wslDistro } : {} mocks.routing.mockReturnValue(routing) const options = routing const target = { remoteName: 'origin', branchName: 'app' } await createWorktree({ baseBranch: undefined, branchNameOverride: 'app', pushTarget: target }) expect(mocks.defaultBase).toHaveBeenCalledWith({ cwd: '/repo', ...options }) expect(mocks.branchName).toHaveBeenCalledWith( '/repo', 'app', 'app', expect.anything(), '', options ) expect(mocks.canCheckout).toHaveBeenCalledWith('/repo', 'app', 'main', options) expect(mocks.branchConflict).toHaveBeenCalledWith('/repo', 'app', 'main', options, undefined) expect(mocks.githubPr).toHaveBeenCalledWith('/repo', 'app', routing) expect(mocks.remoteBase).toHaveBeenCalledWith('/repo', 'main', options) expect(mocks.hasBase).toHaveBeenCalledWith('/repo', 'main', options) expect(mocks.consume).toHaveBeenCalledWith(expect.objectContaining({ options })) expect(mocks.pushTarget).toHaveBeenCalledWith(worktreePath, 'app', target, options) expect(mocks.listing).toHaveBeenCalledWith('/repo', worktreePath, 'app', options) expect(mocks.resolveShared).toHaveBeenCalledWith('/repo', options) expect(mocks.resolveInclude).toHaveBeenCalledWith('/repo', options) } ) it('creates through interactive headroom when regular Git capacity is occupied', async () => { mocks.consume.mockResolvedValue({ status: 'miss', reason: 'none_armed' }) const scheduler = new GitAdmissionScheduler({ generalCap: 1, generalHeadroom: 1 }) _resetGitAdmissionForTests(scheduler) const blocker = await acquireGitAdmission({ args: ['status'], cwd: '/repo' }) mocks.add.mockImplementation( async ( _repo: string, _path: string, _branch: string, _base: string, _refresh: boolean, _existing: boolean, options?: AddWorktreeOptions ) => { const grant = await acquireGitAdmission({ args: ['worktree', 'add'], cwd: '/repo', tier: options?.admissionTier, signal: AbortSignal.timeout(200) }) grant.release() return {} } ) try { await expect(createWorktree()).resolves.toHaveProperty('worktreePath', worktreePath) expect(mocks.add).toHaveBeenCalledOnce() } finally { blocker.release() _resetGitAdmissionForTests() } }) it.each([ ['exactly its directories', ['packages/ui', 'apps/web'], 'preset-web'], ['an edited selection', ['apps/web'], undefined] ])('records the sparse preset only for %s', async (_case, directories, recorded) => { writtenMeta.length = 0 await createWorktree({ sparseCheckout: { directories, presetId: 'preset-web' } }) expect(writtenMeta.find((meta) => meta.sparseDirectories)?.sparsePresetId).toBe(recorded) }) it('still creates the worktree, with no sparse preset, when presets cannot be read', async () => { writtenMeta.length = 0 readSparsePresets.mockImplementation(() => { throw new Error('corrupt presets') }) await createWorktree({ sparseCheckout: { directories: ['apps/web', 'packages/ui'], presetId: 'preset-web' } }) const sparseMeta = writtenMeta.find((meta) => meta.sparseDirectories) expect(sparseMeta?.sparseDirectories).toEqual(['apps/web', 'packages/ui']) expect(sparseMeta?.sparsePresetId).toBeUndefined() }) it('preserves priority for sparse creates and remote base refreshes', async () => { const base = { remote: 'origin', branch: 'main', ref: 'refs/remotes/origin/main', base: 'origin/main' } mocks.remoteBase.mockResolvedValue(base) await createWorktree({ baseBranch: 'origin/main', sparseCheckout: { directories: ['src'] } }) const options = {} expect(mocks.hasRemoteRef).toHaveBeenCalledWith('/repo', base, options) expect(mocks.refresh).toHaveBeenCalledWith('/repo', base, options) expect(mocks.addSparse).toHaveBeenCalledWith( '/repo', worktreePath, 'app', ['src'], 'origin/main', false, expect.objectContaining(options) ) expect(mocks.consume).not.toHaveBeenCalled() }) }) describe('runtime create base without a tracking ref', () => { const originMain = { remote: 'origin', branch: 'main', ref: 'refs/remotes/origin/main', base: 'origin/main' } beforeEach(() => { mocks.remoteBase.mockResolvedValue(originMain) mocks.hasRemoteRef.mockResolvedValue(false) // Only the local branch the remote names exists; `origin/main` itself does not resolve. mocks.hasBase.mockImplementation(async (_repo: string, ref: string) => ref === 'main') }) it('fetches the remote base first and creates from it when the fetch works', async () => { mocks.refresh.mockImplementation(async () => { mocks.hasRemoteRef.mockResolvedValue(true) return { ok: true } }) const result = await createWorktree({ baseBranch: 'origin/main' }) expect(mocks.refresh).toHaveBeenCalledOnce() expect(mocks.consume).toHaveBeenCalledWith( expect.objectContaining({ baseBranch: 'origin/main', options: expect.objectContaining({ remoteTrackingBase: originMain }) }) ) expect(result).not.toHaveProperty('baseFallback') expect(result.worktree.baseRef).toBe('refs/remotes/origin/main') }) it('names the workspace only after the fetch has settled', async () => { let refreshSettled = false mocks.refresh.mockImplementation(async () => { await Promise.resolve() mocks.hasRemoteRef.mockResolvedValue(true) refreshSettled = true return { ok: true } }) const settledAtNaming: boolean[] = [] mocks.canCheckout.mockImplementation(async () => { settledAtNaming.push(refreshSettled) return false }) await createWorktree({ baseBranch: 'origin/main', branchNameOverride: 'app' }) expect(settledAtNaming).toEqual([true]) expect(mocks.canCheckout).toHaveBeenCalledWith('/repo', 'app', 'origin/main', {}) expect(mocks.branchConflict).toHaveBeenCalledWith('/repo', 'app', 'origin/main', {}, undefined) }) it('keeps the not-found error when the fetch works but the tracking ref is still missing', async () => { mocks.hasBase.mockResolvedValue(false) mocks.refresh.mockResolvedValue({ ok: true }) await expect(createWorktree({ baseBranch: 'origin/main' })).rejects.toThrow( 'Base ref "origin/main" was not found after fetching.' ) expect(mocks.consume).not.toHaveBeenCalled() }) it('creates from the local branch and reports it when the fetch fails', async () => { mocks.refresh.mockResolvedValue({ ok: false, errorKind: 'git_error' }) const result = await createWorktree({ baseBranch: 'origin/main', allowLocalBaseFallback: true }) expect(mocks.consume).toHaveBeenCalledWith( expect.objectContaining({ baseBranch: 'main', options: expect.not.objectContaining({ remoteTrackingBase: expect.anything() }) }) ) expect(result.baseFallback).toEqual({ requestedRef: 'origin/main', localRef: 'main' }) expect(result.addResult).not.toHaveProperty('baseFallback') expect(result.worktree.baseRef).toBe('main') }) it('decides the base before branch reuse and conflict checks', async () => { mocks.refresh.mockResolvedValue({ ok: false, errorKind: 'git_error' }) await createWorktree({ baseBranch: 'origin/main', branchNameOverride: 'app', allowLocalBaseFallback: true }) expect(mocks.refresh.mock.invocationCallOrder[0]).toBeLessThan( mocks.canCheckout.mock.invocationCallOrder[0] ) expect(mocks.canCheckout).toHaveBeenCalledWith('/repo', 'app', 'main', {}) expect(mocks.branchConflict).toHaveBeenCalledWith('/repo', 'app', 'main', {}, undefined) }) it("keeps the network error when the fetch fails and there's no local branch", async () => { mocks.hasBase.mockResolvedValue(false) mocks.refresh.mockResolvedValue({ ok: false, errorKind: 'git_error' }) await expect( createWorktree({ baseBranch: 'origin/main', allowLocalBaseFallback: true }) ).rejects.toThrow( 'Could not refresh base ref "origin/main" from "origin". Check your network and try again.' ) expect(mocks.branchName).not.toHaveBeenCalled() expect(mocks.consume).not.toHaveBeenCalled() }) it('keeps the network error for a create that did not opt into the fallback', async () => { mocks.refresh.mockResolvedValue({ ok: false, errorKind: 'git_error' }) await expect(createWorktree({ baseBranch: 'origin/main' })).rejects.toThrow( 'Could not refresh base ref "origin/main" from "origin". Check your network and try again.' ) expect(mocks.consume).not.toHaveBeenCalled() }) it('uses a local ref of the requested name without fetching or reporting a fallback', async () => { mocks.hasBase.mockResolvedValue(true) const result = await createWorktree({ baseBranch: 'origin/main' }) expect(mocks.refresh).not.toHaveBeenCalled() expect(mocks.consume).toHaveBeenCalledWith( expect.objectContaining({ baseBranch: 'origin/main' }) ) expect(result).not.toHaveProperty('baseFallback') }) }) describe('runtime create setup decision', () => { const askRepo: Partial = { hookSettings: { ...getDefaultRepoHookSettings(), setupRunPolicy: 'ask' } } beforeEach(() => { mocks.effectiveHooks.mockReturnValue({ scripts: { setup: 'pnpm install' } }) }) it('refuses an ask repo with no decision before any git work', async () => { const timing = createWorktreeCreateTimingRecorder() // No requested base, so a create that got past the check would resolve the default base. const request = { baseBranch: undefined } const refusal = await createWorktree(request, undefined, timing, askRepo).catch( (error: unknown) => error ) expect(refusal).toBeInstanceOf(WorktreeCreateSetupChoiceRefusedError) expect(refusal).toMatchObject({ message: 'Setup decision required for this repository' }) // Hooks come from the main checkout (no worktree path): the new worktree doesn't exist yet. expect(mocks.effectiveHooks.mock.calls).toEqual([[expect.objectContaining({ path: '/repo' })]]) for (const gitWork of [mocks.defaultBase, mocks.remoteBase, mocks.hasBase, mocks.refresh]) { expect(gitWork).not.toHaveBeenCalled() } expect(mocks.fetch).not.toHaveBeenCalled() expect(mocks.branchName).not.toHaveBeenCalled() expect(mocks.consume).not.toHaveBeenCalled() expect(mocks.add).not.toHaveBeenCalled() // The refusal's failure telemetry still says where the create ran. expect(timing.finish().executionHost).toBe('local') }) it.each([ ['an explicit decision', { setupDecision: 'skip' as const }], ['runHooks', { runHooks: true }] ])('creates an ask repo once the request carries %s', async (_label, request) => { await createWorktree(request, undefined, undefined, askRepo) expect(mocks.consume).toHaveBeenCalledOnce() }) }) describe('runtime label-only creation through first work', () => { let actual: typeof RuntimeWorktreeCreateGit // Load the real module graph before any test timeout starts. beforeAll(async () => { actual = await vi.importActual('./runtime-worktree-create-git') }) function useRealBranchSelection() { mocks.branchName.mockImplementation(actual.resolveCreateBranchName) mocks.listing.mockImplementation(async (_repoPath, path, branch) => ({ created: { ...mocks.created, path, branch: `refs/heads/${branch}` } })) } it.each(labelOnlyCreateRequests)( 'creates and renames a creature branch for $name while projecting its label', async (request) => { useRealBranchSelection() const { worktree } = await createWorktree(request, undefined, undefined, {}, true) const branch = worktree.branch.replace(/^refs\/heads\//, '') expect(isAutoGeneratedCreatureBranchName(branch)).toBe(true) expect(worktree.displayName).toBe(request.name) expect(worktree.displayNameMode).toBe(request.nameWasGenerated ? 'automatic' : 'fixed') const renamed = await renameCreatedWorktreeOnFirstWork(worktree, writtenMeta[0], mocks.git) expect(renamed).toMatchObject({ branch: 'refs/heads/fix-auth', displayName: request.nameWasGenerated ? 'Fix auth' : request.name, displayNameMode: 'fixed' }) } ) it.each([ { request: { name: 'typed-label', branchNameOverride: 'feature/exact' }, enabled: true, branch: 'feature/exact' }, { request: { name: 'cli-exact', cliProvenance: { kind: 'created-by-cli' as const, createdAt: 1 } }, enabled: true, branch: 'cli-exact' }, { request: { name: 'typed-label' }, enabled: false, branch: 'typed-label' } ])( 'preserves branch choice $branch (automatic=$enabled)', async ({ request, enabled, branch }) => { useRealBranchSelection() const { worktree } = await createWorktree(request, undefined, undefined, {}, enabled) expect(worktree).toMatchObject({ branch: `refs/heads/${branch}`, displayName: request.name, displayNameMode: 'fixed' }) } ) })