wind-agent-cli 1.37.2

package/server/modules/worktrees/services/worktree-merge.service.ts

@@ -0,0 +1,157 @@
+import type {
+  GitCommandRunner,
+  MergeWorktreeInput,
+  MergeWorktreeResult,
+  RemoveWorktreeInput,
+  RemoveWorktreeResult,
+} from '@/shared/types.js';
+import { AppError } from '@/shared/utils.js';
+import {
+  countChangedFiles,
+  findWorktreeEntryByPath,
+  listWorktreePorcelainEntries,
+} from '@/modules/worktrees/services/worktree-git.service.js';
+
+/** Reads the paths currently in conflict inside the main worktree (best effort). */
+async function readConflictedFiles(repositoryRoot: string, runGit: GitCommandRunner): Promise<string[]> {
+  try {
+    const { stdout } = await runGit(['diff', '--name-only', '--diff-filter=U'], repositoryRoot);
+    return stdout.split('\n').filter((line) => line.trim().length > 0);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Merges a worktree's branch back into the base branch (the branch checked out
+ * in the main worktree). Runs entirely inside the main worktree, so the user's
+ * current worktree never changes underneath them.
+ *
+ * Both worktrees must be clean: the source so no work is silently left behind,
+ * the target so a conflict can be rolled back without touching user changes.
+ * On conflict the merge is fully aborted and the conflicting paths are
+ * reported back to the client.
+ */
+export async function mergeWorktree(
+  input: MergeWorktreeInput,
+  dependencies: {
+    runGit: GitCommandRunner;
+    removeWorktree: (input: RemoveWorktreeInput) => Promise<RemoveWorktreeResult>;
+  },
+): Promise<MergeWorktreeResult> {
+  const { removeWorktree, runGit } = dependencies;
+  const entries = await listWorktreePorcelainEntries(input.projectPath, runGit);
+  const entry = findWorktreeEntryByPath(entries, input.worktreePath);
+  const repositoryRoot = entries[0].path;
+  const targetBranch = entries[0].branch;
+
+  if (entry.path === repositoryRoot) {
+    throw new AppError('The main worktree cannot be merged into itself', {
+      code: 'WORKTREE_MERGE_MAIN',
+      statusCode: 400,
+    });
+  }
+
+  if (!entry.branch) {
+    throw new AppError('Worktree is on a detached HEAD — check out a branch first', {
+      code: 'WORKTREE_DETACHED_HEAD',
+      statusCode: 400,
+    });
+  }
+
+  if (!targetBranch) {
+    throw new AppError('The main worktree is on a detached HEAD — cannot determine merge target', {
+      code: 'WORKTREE_TARGET_DETACHED',
+      statusCode: 400,
+    });
+  }
+
+  const sourceChangedCount = await countChangedFiles(entry.path, runGit);
+  if (sourceChangedCount > 0) {
+    throw new AppError(
+      `Worktree has ${sourceChangedCount} uncommitted change${sourceChangedCount === 1 ? '' : 's'} — commit or discard them first`,
+      { code: 'WORKTREE_SOURCE_DIRTY', statusCode: 409 },
+    );
+  }
+
+  const targetChangedCount = await countChangedFiles(repositoryRoot, runGit);
+  if (targetChangedCount > 0) {
+    throw new AppError(
+      `The base worktree (${targetBranch}) has uncommitted changes — commit or stash them first`,
+      { code: 'WORKTREE_TARGET_DIRTY', statusCode: 409 },
+    );
+  }
+
+  const squash = Boolean(input.squash);
+  const message =
+    input.message?.trim() ||
+    (squash ? `Squash merge branch '${entry.branch}'` : `Merge branch '${entry.branch}'`);
+
+  try {
+    if (squash) {
+      await runGit(['merge', '--squash', entry.branch], repositoryRoot);
+      await runGit(['commit', '-m', message], repositoryRoot);
+    } else {
+      await runGit(['merge', '--no-ff', entry.branch, '-m', message], repositoryRoot);
+    }
+  } catch (error) {
+    const conflictedFiles = await readConflictedFiles(repositoryRoot, runGit);
+    // Roll the main worktree back to its pre-merge state. `--merge` also
+    // clears a half-applied squash since the target was verified clean above.
+    try {
+      await runGit(['reset', '--merge'], repositoryRoot);
+    } catch (rollbackError) {
+      throw new AppError(
+        `Merge of '${entry.branch}' into '${targetBranch}' failed and could not be rolled back`,
+        {
+          code: 'WORKTREE_MERGE_ROLLBACK_FAILED',
+          statusCode: 500,
+          details: {
+            mergeError: error instanceof Error ? error.message : String(error),
+            rollbackError: rollbackError instanceof AppError
+              ? rollbackError.details ?? rollbackError.message
+              : rollbackError instanceof Error ? rollbackError.message : String(rollbackError),
+          },
+        },
+      );
+    }
+
+    if (conflictedFiles.length > 0) {
+      throw new AppError(
+        `Merge of '${entry.branch}' into '${targetBranch}' has conflicts — the merge was aborted`,
+        {
+          code: 'WORKTREE_MERGE_CONFLICT',
+          statusCode: 409,
+          details: conflictedFiles,
+        },
+      );
+    }
+
+    throw error;
+  }
+
+  let removedWorktree: RemoveWorktreeResult | null = null;
+  let cleanupError: string | null = null;
+  if (input.removeAfterMerge) {
+    try {
+      removedWorktree = await removeWorktree(
+        {
+          projectPath: repositoryRoot,
+          worktreePath: entry.path,
+          force: false,
+          deleteBranch: true,
+        },
+      );
+    } catch (error) {
+      cleanupError = error instanceof Error ? error.message : String(error);
+    }
+  }
+
+  return {
+    mergedBranch: entry.branch,
+    targetBranch,
+    squash,
+    removedWorktree,
+    cleanupError,
+  };
+}

package/server/modules/worktrees/services/worktree-open.service.ts

@@ -0,0 +1,85 @@
+import path from 'node:path';
+
+import type {
+  GitCommandRunner,
+  OpenWorktreeInput,
+  ProjectRepositoryRow,
+  WorktreeProjectGateway,
+  WorktreeProjectView,
+} from '@/shared/types.js';
+import { AppError, normalizeProjectPath } from '@/shared/utils.js';
+import {
+  findWorktreeEntryByPath,
+  listWorktreePorcelainEntries,
+} from '@/modules/worktrees/services/worktree-git.service.js';
+
+function mapRowToProjectView(row: ProjectRepositoryRow): WorktreeProjectView {
+  return {
+    projectId: row.project_id,
+    path: row.project_path,
+    fullPath: row.project_path,
+    displayName: row.custom_project_name || path.basename(row.project_path),
+    isStarred: Boolean(row.isStarred),
+    sessions: [],
+    sessionMeta: { hasMore: false, total: 0 },
+  };
+}
+
+/**
+ * Ensures a CloudCLI project exists (and is active) for a worktree directory
+ * and returns it, so the caller can switch the UI into that worktree.
+ *
+ * The path is only accepted when it is a registered worktree of the repository
+ * that contains `projectPath` — this endpoint must never become a generic
+ * "create project anywhere" backdoor.
+ */
+export async function openWorktreeAsProject(
+  input: OpenWorktreeInput,
+  dependencies: {
+    runGit: GitCommandRunner;
+    projects: Pick<
+      WorktreeProjectGateway,
+      'getProjectByPath' | 'createProject' | 'restoreProject'
+    >;
+  },
+): Promise<WorktreeProjectView> {
+  const { projects, runGit } = dependencies;
+  const entries = await listWorktreePorcelainEntries(input.projectPath, runGit);
+  const entry = findWorktreeEntryByPath(entries, input.worktreePath);
+
+  const normalizedWorktreePath = normalizeProjectPath(entry.path);
+  const repoName = path.basename(entries[0].path);
+  // "repo · branch" keeps worktree projects visually grouped next to their
+  // parent repository in the sidebar.
+  const displayName = entry.branch ? `${repoName} · ${entry.branch}` : repoName;
+
+  const existingRow = projects.getProjectByPath(normalizedWorktreePath);
+  if (existingRow) {
+    if (existingRow.isArchived) {
+      await projects.restoreProject(existingRow.project_id);
+    }
+    const refreshedRow = projects.getProjectByPath(normalizedWorktreePath) ?? existingRow;
+    return mapRowToProjectView(refreshedRow);
+  }
+
+  const created = await projects.createProject({
+    projectPath: normalizedWorktreePath,
+    customName: displayName,
+  });
+
+  // `createProject` intentionally keeps reactivated archived rows archived;
+  // an opened worktree must be active so it shows up in the sidebar.
+  if (created.outcome === 'reactivated_archived') {
+    await projects.restoreProject(created.project.projectId);
+  }
+
+  const row = projects.getProjectByPath(normalizedWorktreePath);
+  if (!row) {
+    throw new AppError('Failed to resolve project for worktree', {
+      code: 'WORKTREE_PROJECT_RESOLVE_FAILED',
+      statusCode: 500,
+    });
+  }
+
+  return mapRowToProjectView(row);
+}

package/server/modules/worktrees/services/worktree-remove.service.ts

@@ -0,0 +1,88 @@
+import type {
+  GitCommandRunner,
+  RemoveWorktreeInput,
+  RemoveWorktreeResult,
+  WorktreeProjectGateway,
+} from '@/shared/types.js';
+import { AppError } from '@/shared/utils.js';
+import {
+  countChangedFiles,
+  findWorktreeEntryByPath,
+  listWorktreePorcelainEntries,
+} from '@/modules/worktrees/services/worktree-git.service.js';
+
+/**
+ * Removes a linked worktree (never the main one), optionally deletes its
+ * branch, and archives the CloudCLI project registered for the directory so it
+ * disappears from the sidebar while its chat history stays recoverable.
+ */
+export async function removeWorktree(
+  input: RemoveWorktreeInput,
+  dependencies: {
+    runGit: GitCommandRunner;
+    projects: Pick<WorktreeProjectGateway, 'getProjectByPath' | 'archiveProject'>;
+  },
+): Promise<RemoveWorktreeResult> {
+  const { projects, runGit } = dependencies;
+  const entries = await listWorktreePorcelainEntries(input.projectPath, runGit);
+  const entry = findWorktreeEntryByPath(entries, input.worktreePath);
+  const repositoryRoot = entries[0].path;
+
+  if (entry.path === repositoryRoot) {
+    throw new AppError('The main worktree cannot be removed', {
+      code: 'WORKTREE_MAIN_NOT_REMOVABLE',
+      statusCode: 400,
+    });
+  }
+
+  if (!input.force) {
+    const changedFileCount = await countChangedFiles(entry.path, runGit);
+    if (changedFileCount > 0) {
+      throw new AppError(
+        `Worktree has ${changedFileCount} uncommitted change${changedFileCount === 1 ? '' : 's'}`,
+        {
+          code: 'WORKTREE_DIRTY',
+          statusCode: 409,
+        },
+      );
+    }
+  }
+
+  const removeArgs = ['worktree', 'remove'];
+  if (input.force) {
+    removeArgs.push('--force');
+  }
+  removeArgs.push(entry.path);
+  await runGit(removeArgs, repositoryRoot);
+
+  let branchDeleted = false;
+  if (input.deleteBranch && entry.branch) {
+    try {
+      await runGit(['branch', '-D', entry.branch], repositoryRoot);
+      branchDeleted = true;
+    } catch {
+      // Branch deletion is best-effort cleanup — the worktree itself is gone,
+      // which is the operation the user asked for.
+    }
+  }
+
+  let archivedProjectId: string | null = null;
+  let archivalError: string | null = null;
+  try {
+    const linkedProject = projects.getProjectByPath(entry.path);
+    if (linkedProject && !linkedProject.isArchived) {
+      await projects.archiveProject(linkedProject.project_id);
+      archivedProjectId = linkedProject.project_id;
+    }
+  } catch (error) {
+    archivalError = error instanceof Error ? error.message : String(error);
+  }
+
+  return {
+    removedPath: entry.path,
+    branch: entry.branch,
+    branchDeleted,
+    archivedProjectId,
+    archivalError,
+  };
+}

package/server/modules/worktrees/tests/worktree-create-and-open.service.test.ts

@@ -0,0 +1,68 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { createAndOpenWorktree } from '@/modules/worktrees/services/worktree-create-and-open.service.js';
+import type { RemoveWorktreeInput } from '@/shared/types.js';
+
+const input = {
+  projectPath: '/workspace/repo',
+  branch: 'feature/login',
+};
+
+test('createAndOpenWorktree returns the registered project', async () => {
+  const result = await createAndOpenWorktree(input, {
+    createWorktree: async () => ({
+      worktreePath: '/workspace/repo-worktrees/feature-login',
+      branch: 'feature/login',
+      createdBranch: true,
+    }),
+    openWorktree: async ({ worktreePath }) => ({
+      projectId: 'project-2',
+      path: worktreePath,
+      fullPath: worktreePath,
+      displayName: 'feature/login',
+      isStarred: false,
+      sessions: [],
+      sessionMeta: { hasMore: false, total: 0 },
+    }),
+    removeWorktree: async () => {
+      throw new Error('unexpected cleanup');
+    },
+  });
+
+  assert.equal(result.project.projectId, 'project-2');
+});
+
+test('createAndOpenWorktree compensates registration failure without deleting an existing branch', async () => {
+  const removals: RemoveWorktreeInput[] = [];
+  const registrationError = new Error('registration failed');
+
+  await assert.rejects(
+    createAndOpenWorktree(input, {
+      createWorktree: async () => ({
+        worktreePath: '/workspace/repo-worktrees/feature-login',
+        branch: 'feature/login',
+        createdBranch: false,
+      }),
+      openWorktree: async () => { throw registrationError; },
+      removeWorktree: async (removeInput) => {
+        removals.push(removeInput);
+        return {
+          removedPath: removeInput.worktreePath,
+          branch: 'feature/login',
+          branchDeleted: false,
+          archivedProjectId: null,
+          archivalError: null,
+        };
+      },
+    }),
+    registrationError,
+  );
+
+  assert.deepEqual(removals, [{
+    projectPath: input.projectPath,
+    worktreePath: '/workspace/repo-worktrees/feature-login',
+    force: true,
+    deleteBranch: false,
+  }]);
+});

package/server/modules/worktrees/tests/worktree-create.service.test.ts

@@ -0,0 +1,142 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { createWorktree } from '@/modules/worktrees/services/worktree-create.service.js';
+import type { GitCommandResult } from '@/shared/types.js';
+import { AppError } from '@/shared/utils.js';
+
+const PORCELAIN = [
+  'worktree /home/user/repo',
+  'HEAD 1111111111111111111111111111111111111111',
+  'branch refs/heads/main',
+  '',
+  'worktree /home/user/repo-worktrees/existing',
+  'HEAD 2222222222222222222222222222222222222222',
+  'branch refs/heads/existing-branch',
+  '',
+].join('\n');
+
+type RecordedCall = { args: string[]; cwd: string };
+
+/**
+ * Fake GitCommandRunner: records every call and answers `worktree list` /
+ * `branch --list` from canned data; everything else succeeds with no output.
+ */
+function createFakeRunner(existingBranches: string[]) {
+  const calls: RecordedCall[] = [];
+  const runner = async (args: string[], cwd: string): Promise<GitCommandResult> => {
+    calls.push({ args, cwd });
+
+    if (args[0] === 'worktree' && args[1] === 'list') {
+      return { stdout: PORCELAIN, stderr: '' };
+    }
+
+    if (args[0] === 'branch' && args[1] === '--list') {
+      const requested = args[2];
+      const matches = existingBranches.filter((branch) => branch === requested);
+      return { stdout: matches.join('\n'), stderr: '' };
+    }
+
+    return { stdout: '', stderr: '' };
+  };
+
+  return { calls, runner };
+}
+
+function createDependencies(runner: ReturnType<typeof createFakeRunner>['runner'], pathExists = false) {
+  return {
+    runGit: runner,
+    fileSystem: {
+      pathExists: async () => pathExists,
+    },
+  };
+}
+
+test('createWorktree creates a new branch from the main branch by default', async () => {
+  const { calls, runner } = createFakeRunner([]);
+
+  const result = await createWorktree(
+    { projectPath: '/home/user/repo', branch: 'feature/login' },
+    createDependencies(runner),
+  );
+
+  assert.equal(result.branch, 'feature/login');
+  assert.equal(result.createdBranch, true);
+  // Slashes in the branch become dashes in the folder name.
+  assert.ok(result.worktreePath.endsWith('feature-login'));
+  assert.ok(result.worktreePath.includes('repo-worktrees'));
+
+  const addCall = calls.find((call) => call.args[0] === 'worktree' && call.args[1] === 'add');
+  assert.ok(addCall, 'expected a worktree add call');
+  assert.deepEqual(addCall.args.slice(3), ['-b', 'feature/login', 'main']);
+});
+
+test('createWorktree checks out an existing branch without -b', async () => {
+  const { calls, runner } = createFakeRunner(['bugfix']);
+
+  const result = await createWorktree(
+    { projectPath: '/home/user/repo', branch: 'bugfix' },
+    createDependencies(runner),
+  );
+
+  assert.equal(result.createdBranch, false);
+
+  const addCall = calls.find((call) => call.args[0] === 'worktree' && call.args[1] === 'add');
+  assert.ok(addCall, 'expected a worktree add call');
+  assert.ok(!addCall.args.includes('-b'));
+  assert.equal(addCall.args.at(-1), 'bugfix');
+});
+
+test('createWorktree honors an explicit base branch', async () => {
+  const { calls, runner } = createFakeRunner([]);
+
+  await createWorktree(
+    { projectPath: '/home/user/repo', branch: 'hotfix', baseBranch: 'release/1.0' },
+    createDependencies(runner),
+  );
+
+  const addCall = calls.find((call) => call.args[0] === 'worktree' && call.args[1] === 'add');
+  assert.ok(addCall);
+  assert.equal(addCall.args.at(-1), 'release/1.0');
+});
+
+test('createWorktree rejects a branch already checked out in another worktree', async () => {
+  const { runner } = createFakeRunner(['existing-branch']);
+
+  await assert.rejects(
+    createWorktree(
+      { projectPath: '/home/user/repo', branch: 'existing-branch' },
+      createDependencies(runner),
+    ),
+    (error: unknown) =>
+      error instanceof AppError && error.code === 'BRANCH_ALREADY_CHECKED_OUT' && error.statusCode === 409,
+  );
+});
+
+test('createWorktree rejects invalid branch names before touching git state', async () => {
+  const { calls, runner } = createFakeRunner([]);
+
+  await assert.rejects(
+    createWorktree(
+      { projectPath: '/home/user/repo', branch: '-rf' },
+      createDependencies(runner),
+    ),
+    (error: unknown) => error instanceof AppError && error.code === 'INVALID_BRANCH_NAME',
+  );
+
+  assert.equal(calls.length, 0);
+});
+
+test('createWorktree rejects an occupied destination without running a mutating git command', async () => {
+  const { calls, runner } = createFakeRunner([]);
+
+  await assert.rejects(
+    createWorktree(
+      { projectPath: '/home/user/repo', branch: 'feature/login' },
+      createDependencies(runner, true),
+    ),
+    (error: unknown) => error instanceof AppError && error.code === 'WORKTREE_FOLDER_EXISTS',
+  );
+
+  assert.equal(calls.some((call) => call.args[0] === 'worktree' && call.args[1] === 'add'), false);
+});

package/server/modules/worktrees/tests/worktree-git.service.test.ts

@@ -0,0 +1,84 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import {
+  findWorktreeEntryByPath,
+  parseWorktreeListPorcelain,
+  validateWorktreeBranchName,
+} from '@/modules/worktrees/services/worktree-git.service.js';
+import { AppError } from '@/shared/utils.js';
+
+const SAMPLE_PORCELAIN = [
+  'worktree /home/user/repo',
+  'HEAD 1111111111111111111111111111111111111111',
+  'branch refs/heads/main',
+  '',
+  'worktree /home/user/repo-worktrees/feature-login',
+  'HEAD 2222222222222222222222222222222222222222',
+  'branch refs/heads/feature/login',
+  '',
+  'worktree /home/user/repo-worktrees/spike',
+  'HEAD 3333333333333333333333333333333333333333',
+  'detached',
+  'locked reason text',
+  '',
+].join('\n');
+
+test('parseWorktreeListPorcelain parses main, branch, detached and locked entries', () => {
+  const entries = parseWorktreeListPorcelain(SAMPLE_PORCELAIN);
+
+  assert.equal(entries.length, 3);
+
+  assert.equal(entries[0].branch, 'main');
+  assert.equal(entries[0].headSha, '1111111111111111111111111111111111111111');
+  assert.equal(entries[0].isDetached, false);
+
+  assert.equal(entries[1].branch, 'feature/login');
+  assert.ok(entries[1].path.endsWith('feature-login'));
+
+  assert.equal(entries[2].branch, null);
+  assert.equal(entries[2].isDetached, true);
+  assert.equal(entries[2].isLocked, true);
+});
+
+test('parseWorktreeListPorcelain handles output without a trailing blank line', () => {
+  const entries = parseWorktreeListPorcelain(
+    'worktree /home/user/repo\nHEAD 1111111111111111111111111111111111111111\nbranch refs/heads/main',
+  );
+
+  assert.equal(entries.length, 1);
+  assert.equal(entries[0].branch, 'main');
+});
+
+test('findWorktreeEntryByPath matches normalized paths', () => {
+  const entries = parseWorktreeListPorcelain(SAMPLE_PORCELAIN);
+  const found = findWorktreeEntryByPath(entries, '/home/user/repo-worktrees/feature-login/');
+  assert.equal(found.branch, 'feature/login');
+});
+
+test('findWorktreeEntryByPath throws a 404 AppError for unknown paths', () => {
+  const entries = parseWorktreeListPorcelain(SAMPLE_PORCELAIN);
+  assert.throws(
+    () => findWorktreeEntryByPath(entries, '/home/user/elsewhere'),
+    (error: unknown) =>
+      error instanceof AppError && error.code === 'WORKTREE_NOT_FOUND' && error.statusCode === 404,
+  );
+});
+
+test('validateWorktreeBranchName accepts slash-separated branch names', () => {
+  assert.equal(validateWorktreeBranchName(' feature/login-form '), 'feature/login-form');
+});
+
+test('validateWorktreeBranchName rejects unsafe names', () => {
+  for (const invalidName of [
+    '', '   ', '-oops', '.', '..', 'bad name', 'bad;name', 'bad$(name)',
+    'foo..bar', 'foo.', 'foo//bar', 'foo.lock', 'feature/foo.LOCK', '/feature', 'feature/',
+    '.hidden', 'feature/.hidden', 'feature/./name',
+  ]) {
+    assert.throws(
+      () => validateWorktreeBranchName(invalidName),
+      (error: unknown) => error instanceof AppError && error.code === 'INVALID_BRANCH_NAME',
+      `expected "${invalidName}" to be rejected`,
+    );
+  }
+});

package/server/modules/worktrees/tests/worktree-list.service.test.ts

@@ -0,0 +1,45 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { listWorktrees } from '@/modules/worktrees/services/worktree-list.service.js';
+import type { GitCommandResult } from '@/shared/types.js';
+
+test('listWorktrees bounds concurrent per-worktree Git inspection and preserves ordering', async () => {
+  const entryCount = 10;
+  const porcelain = Array.from({ length: entryCount }, (_, index) => [
+    `worktree /workspace/repo-${index}`,
+    `HEAD ${String(index).padStart(40, '0')}`,
+    `branch refs/heads/${index === 0 ? 'main' : `feature/${index}`}`,
+    '',
+  ].join('\n')).join('\n');
+  let activeCommands = 0;
+  let maximumActiveCommands = 0;
+
+  const runGit = async (args: string[]): Promise<GitCommandResult> => {
+    if (args[0] === 'worktree') {
+      return { stdout: porcelain, stderr: '' };
+    }
+
+    activeCommands += 1;
+    maximumActiveCommands = Math.max(maximumActiveCommands, activeCommands);
+    await new Promise((resolve) => setTimeout(resolve, 5));
+    activeCommands -= 1;
+
+    if (args[0] === 'log') {
+      return { stdout: 'subject\0' + '2026-01-01T00:00:00Z', stderr: '' };
+    }
+    if (args[0] === 'rev-list') {
+      return { stdout: '0 1', stderr: '' };
+    }
+    return { stdout: '', stderr: '' };
+  };
+
+  const result = await listWorktrees(
+    { projectPath: '/workspace/repo-0' },
+    { runGit, getProjectByPath: () => null },
+  );
+
+  assert.equal(maximumActiveCommands <= 12, true);
+  assert.deepEqual(result.worktrees.map((worktree) => worktree.path.replace(/\\/g, '/')),
+    Array.from({ length: entryCount }, (_, index) => `/workspace/repo-${index}`));
+});