@teambit/ci 0.0.0-e308aa46791bdab3538e682864e5a61a001dfd3d → 0.0.0-e30ef93ccee6b6078f8ab7ea6c002fca3263c9c3

package/ci.docs.mdx

@@ -83,18 +83,51 @@ Publishes new semantic versions after a PR merges to `main`.
 bit ci merge [--message <string>] [--build] [--increment <level>] [--patch|--minor|--major] [--increment-by <number>]
 ```
 
-| Flag              | Shorthand | Description                                                                                                         |
-| ----------------- | --------- | ------------------------------------------------------------------------------------------------------------------- |
-| `--message`       | `-m`      | Changelog entry (defaults to last Git commit message).                                                              |
-| `--build`         | `-b`      | Build locally (otherwise Ripple-CI does it). Required if workspace contains _soft-tagged_ components.               |
-| `--strict`        | `-s`      | Fail on warnings as well as errors (default: only fails on errors).                                                 |
-| `--increment`     | `-l`      | Version bump level: `major`, `premajor`, `minor`, `preminor`, `patch`, `prepatch`, `prerelease` (default: `patch`). |
-| `--patch`         | `-p`      | Shortcut for `--increment patch`.                                                                                   |
-| `--minor`         |           | Shortcut for `--increment minor`.                                                                                   |
-| `--major`         |           | Shortcut for `--increment major`.                                                                                   |
-| `--pre-release`   |           | Shortcut for `--increment prerelease` with optional identifier.                                                     |
-| `--prerelease-id` |           | Prerelease identifier (e.g. "dev" to get "1.0.0-dev.1").                                                            |
-| `--increment-by`  |           | Increment by more than 1 (e.g. `--increment-by 2` with patch: 0.0.1 → 0.0.3).                                       |
+| Flag                   | Shorthand | Description                                                                                                         |
+| ---------------------- | --------- | ------------------------------------------------------------------------------------------------------------------- |
+| `--message`            | `-m`      | Changelog entry (defaults to last Git commit message).                                                              |
+| `--build`              | `-b`      | Build locally (otherwise Ripple-CI does it). Required if workspace contains _soft-tagged_ components.               |
+| `--strict`             | `-s`      | Fail on warnings as well as errors (default: only fails on errors).                                                 |
+| `--increment`          | `-l`      | Version bump level: `major`, `premajor`, `minor`, `preminor`, `patch`, `prepatch`, `prerelease` (default: `patch`). |
+| `--patch`              | `-p`      | Shortcut for `--increment patch`.                                                                                   |
+| `--minor`              |           | Shortcut for `--increment minor`.                                                                                   |
+| `--major`              |           | Shortcut for `--increment major`.                                                                                   |
+| `--pre-release`        |           | Shortcut for `--increment prerelease` with optional identifier.                                                     |
+| `--prerelease-id`      |           | Prerelease identifier (e.g. "dev" to get "1.0.0-dev.1").                                                            |
+| `--increment-by`       |           | Increment by more than 1 (e.g. `--increment-by 2` with patch: 0.0.1 → 0.0.3).                                       |
+| `--auto-tag-increment` |           | Version bump level for auto-tagged dependents. See below.                                                           |
+
+### Bumping Dependents
+
+The version flags above apply only to the components that actually changed. Dependents that are
+picked up by auto-tag are bumped by a `patch`, regardless of `--major`/`--minor`:
+
+```bash
+# button 1.0.0 -> 2.0.0, but its dependent lib 1.0.0 -> 1.0.1
+bit ci merge --major
+```
+
+The one exception is a pre-release `--increment` (`prepatch`, `prerelease`, `preminor`,
+`premajor`), which the dependents do follow:
+
+```bash
+# button 1.0.0 -> 1.0.1-0, and its dependent lib 1.0.0 -> 1.0.1-0 too
+bit ci merge --increment prerelease
+```
+
+Use `--auto-tag-increment` to bump the dependents by an explicit level instead. It overrides both
+defaults above:
+
+```bash
+# button 1.0.0 -> 2.0.0, and its dependent lib 1.0.0 -> 2.0.0 as well
+bit ci merge --major --auto-tag-increment major
+```
+
+The two levels are independent, so `--major --auto-tag-increment minor` is also valid.
+
+**Note**: auto-tag is transitive — a dependent of a dependent is auto-tagged too. So
+`--auto-tag-increment major` bumps the _entire_ dependents graph by a major, not just the direct
+dependents. It cannot be combined with `--skip-auto-tag`.
 
 ### Automatic Version Bump Detection
 
@@ -113,7 +146,7 @@ When **no explicit version flags** are provided, `bit ci merge` can automaticall
 
 3. **Default**: patch version bump
 
-**Note**: Auto-detection only occurs when no version flags (`--patch`, `--minor`, `--major`, etc.) are provided. Explicit flags always take precedence.
+**Note**: Auto-detection only occurs when no version flags (`--patch`, `--minor`, `--major`, etc.) are provided. Explicit flags always take precedence. `--auto-tag-increment` is not considered a version flag for this purpose — it only affects dependents, so it can be combined with auto-detection.
 
 ### Internal flow
 

package/commands/merge.cmd.ts

@@ -3,6 +3,8 @@ import type { Logger } from '@teambit/logger';
 import { OutsideWorkspaceError, type Workspace } from '@teambit/workspace';
 import type { ReleaseType } from 'semver';
 import { validateOptions } from '@teambit/snapping';
+import { BitError } from '@teambit/bit-error';
+import type { MergeStrategy } from '@teambit/component.modules.merge-helper';
 import type { CiMain } from '../ci.main.runtime';
 
 type Options = {
@@ -10,6 +12,7 @@ type Options = {
   build?: boolean;
   strict?: boolean;
   increment?: ReleaseType;
+  autoTagIncrement?: ReleaseType;
   patch?: boolean;
   minor?: boolean;
   major?: boolean;
@@ -18,11 +21,17 @@ type Options = {
   incrementBy?: number;
   verbose?: boolean;
   versionsFile?: string;
+  autoMergeResolve?: MergeStrategy;
+  forceTheirs?: boolean;
+  laneName?: string;
+  skipPush?: boolean;
+  noBitmapCommit?: boolean;
 };
 
 export class CiMergeCmd implements Command {
   name = 'merge';
-  description = 'Merges a PR';
+  description = 'Tags and exports new semantic versions after merging a PR to main.';
+  extendedDescription = `By default, bumps patch versions when merging to main. If specific configuration variables are set, it can use commit messages or explicit flags to determine the version bump. Runs install, tag, build, and export, then archives the remote lane and syncs lockfiles. Use in merge-to-main CI pipelines to publish releases.`;
   group = 'collaborate';
 
   options: CommandOptions = [
@@ -39,6 +48,13 @@ export class CiMergeCmd implements Command {
     ['', 'minor', 'syntactic sugar for "--increment minor"'],
     ['', 'major', 'syntactic sugar for "--increment major"'],
     ['', 'pre-release [identifier]', 'syntactic sugar for "--increment prerelease" and `--prerelease-id <identifier>`'],
+    [
+      '',
+      'auto-tag-increment <level>',
+      `the increment level to use for auto-tagged dependents. options are: [major, premajor, minor, preminor, patch, prepatch, prerelease].
+by default, dependents are bumped by a patch, unless --increment is one of [prepatch, prerelease, preminor, premajor], which they follow.
+note that dependents are auto-tagged transitively, so the entire dependents graph is bumped by this level`,
+    ],
     [
       '',
       'increment-by <number>',
@@ -46,6 +62,19 @@ export class CiMergeCmd implements Command {
     ],
     ['', 'versions-file <path>', 'path to a file containing component versions. format: "component-id: version"'],
     ['', 'verbose', 'show verbose output'],
+    [
+      'r',
+      'auto-merge-resolve <merge-strategy>',
+      'in case of merge conflict during checkout, resolve according to the provided strategy: [ours, theirs, manual]',
+    ],
+    ['', 'force-theirs', 'do not merge during checkout, just overwrite with incoming files'],
+    ['', 'lane-name <name>', 'specify the lane name to delete after merge (auto-detected if not provided)'],
+    ['', 'skip-push', 'skip pushing the changes to the remote repository (useful when CI handles the push separately)'],
+    [
+      '',
+      'no-bitmap-commit',
+      'skip the post-tag git add/commit/push entirely. The new versions still land in the scope, but no .bitmap (or lockfile) commit is created on the default branch. Pair with `bitmapAutoSync: true` in workspace.jsonc so developers auto-sync their local .bitmap on the first bit command after `git pull`.',
+    ],
   ];
 
   constructor(
@@ -59,9 +88,21 @@ export class CiMergeCmd implements Command {
     this.logger.console('🚀 Initializing Merge command');
     if (!this.workspace) throw new OutsideWorkspaceError();
 
-    const { releaseType, preReleaseId } = validateOptions(options);
+    // Validate autoMergeResolve option
+    if (
+      options.autoMergeResolve &&
+      options.autoMergeResolve !== 'ours' &&
+      options.autoMergeResolve !== 'theirs' &&
+      options.autoMergeResolve !== 'manual'
+    ) {
+      throw new BitError('--auto-merge-resolve must be one of the following: [ours, theirs, manual]');
+    }
+
+    const { releaseType, autoTagReleaseType, preReleaseId } = validateOptions(options);
 
-    // Check if user explicitly provided any version bump flags
+    // Check if user explicitly provided any version bump flags.
+    // --auto-tag-increment is deliberately excluded: it only affects dependents, so it shouldn't
+    // disable the commit-message auto-detection that determines the modified components' bump.
     const explicitVersionBump = Boolean(
       options.increment || options.patch || options.minor || options.major || options.preRelease
     );
@@ -71,11 +112,17 @@ export class CiMergeCmd implements Command {
       build: options.build,
       strict: options.strict,
       releaseType,
+      autoTagReleaseType,
       preReleaseId,
       incrementBy: options.incrementBy,
       explicitVersionBump,
       verbose: options.verbose,
       versionsFile: options.versionsFile,
+      autoMergeResolve: options.autoMergeResolve,
+      forceTheirs: options.forceTheirs,
+      laneName: options.laneName,
+      skipPush: options.skipPush,
+      noBitmapCommit: options.noBitmapCommit,
     });
   }
 }

package/commands/pr.cmd.ts

@@ -8,11 +8,16 @@ type Options = {
   build?: boolean;
   lane?: string;
   strict?: boolean;
+  dryRun?: boolean;
+  keepLane?: boolean;
+  skipCleanup?: boolean;
+  skipTasks?: string;
 };
 
 export class CiPrCmd implements Command {
   name = 'pr';
-  description = 'This command is meant to run when a PR was open/updated and meant to export a lane to bit-cloud.';
+  description = 'Exports a feature lane to Bit Cloud when a Pull Request is opened or updated.';
+  extendedDescription = `Resolves the lane name from --lane or the current Git branch, validates it, and runs install, status, snap, and export. By default it then restores the workspace by switching back to main; pass --skip-cleanup to skip that restore when the workspace is about to be discarded (e.g. an ephemeral CI container). PR builds run the full pipeline by default; to trade specific tasks for speed on a given PR, add a [skip-tasks: ...] token to the commit message (e.g. [skip-tasks: GeneratePreview,ExtractSchema]), which merges with any --skip-tasks flag. Use in pull-request CI pipelines after tests and before deploy.`;
   group = 'collaborate';
 
   options: CommandOptions = [
@@ -20,6 +25,22 @@ export class CiPrCmd implements Command {
     ['l', 'lane <lane>', 'If set, use as the lane name, if not available, grab from git-branch name'],
     ['b', 'build', 'Set to true to build the app locally, false (default) will build on Ripple CI'],
     ['s', 'strict', 'Set to true to fail on warnings as well as errors, false (default) only fails on errors'],
+    ['d', 'dry-run', 'Run the full pipeline but skip exporting to remote (build runs only if --build is set)'],
+    [
+      '',
+      'keep-lane',
+      'Reuse the same remote lane across PR commits (preserves lane history and cloud UI edits) instead of recreating it on every run',
+    ],
+    [
+      '',
+      'skip-cleanup',
+      'Skip restoring the workspace (switching back to main) after export. Use when the workspace is discarded right after, e.g. an ephemeral CI container',
+    ],
+    [
+      '',
+      'skip-tasks <tasks>',
+      `Comma-separated list of build/publish task names (or aspect-ids) to skip during snap, e.g. "ExtractSchema,GeneratePreview,GenerateEnvTemplate,PublishComponents". Speeds up PR builds by trading optional artifacts (schema/preview) and publishing for build time; they are produced on the final export to main`,
+    ],
   ];
 
   constructor(
@@ -45,9 +66,7 @@ export class CiPrCmd implements Command {
       if (!currentBranch) {
         throw new Error('Failed to get branch name');
       }
-      // Sanitize branch name to make it valid for Bit lane IDs by replacing slashes with dashes
-      const sanitizedBranch = currentBranch.replace(/\//g, '-');
-      laneIdStr = `${this.workspace.defaultScope}/${sanitizedBranch}`;
+      laneIdStr = this.ci.convertBranchToLaneId(currentBranch);
     }
 
     if (options.message) {
@@ -65,6 +84,10 @@ export class CiPrCmd implements Command {
       message,
       build: options.build,
       strict: options.strict,
+      dryRun: options.dryRun,
+      keepLane: options.keepLane,
+      skipCleanup: options.skipCleanup,
+      skipTasks: options.skipTasks,
     });
 
     if (results) {

package/commands/verify.cmd.ts

@@ -5,7 +5,8 @@ import type { CiMain } from '../ci.main.runtime';
 
 export class CiVerifyCmd implements Command {
   name = 'verify';
-  description = 'CI commands';
+  description = 'Ensures the workspace passes CI checks on every commit.';
+  extendedDescription = `Runs lint, build, and status checks to catch dependency drift or broken builds early. Typically used as a pre-push hook or early CI job. Stops at the first failing step and returns a non-zero exit code.`;
   group = 'development';
 
   options: CommandOptions = [];

package/dist/ci.cmd.d.ts

@@ -6,6 +6,7 @@ export declare class CiCmd implements Command {
     private logger;
     name: string;
     description: string;
+    extendedDescription: string;
     group: string;
     options: CommandOptions;
     commands: Command[];

package/dist/ci.cmd.js

@@ -12,7 +12,8 @@ class CiCmd {
     this.workspace = workspace;
     this.logger = logger;
     _defineProperty(this, "name", 'ci <sub-command>');
-    _defineProperty(this, "description", 'CI commands');
+    _defineProperty(this, "description", 'continuous integration commands for automated workflows');
+    _defineProperty(this, "extendedDescription", 'provides commands designed for use in CI/CD pipelines with Git workflows to automate component development tasks like verification, pull request handling, and deployment preparation.');
     _defineProperty(this, "group", 'collaborate');
     _defineProperty(this, "options", []);
     _defineProperty(this, "commands", []);

package/dist/ci.cmd.js.map

@@ -1 +1 @@
-{"version":3,"names":["CiCmd","constructor","workspace","logger","_defineProperty","report","code","data","exports"],"sources":["ci.cmd.ts"],"sourcesContent":["import type { Command, CommandOptions } from '@teambit/cli';\nimport type { Logger } from '@teambit/logger';\nimport type { Workspace } from '@teambit/workspace';\n\nexport class CiCmd implements Command {\n  name = 'ci <sub-command>';\n  description = 'CI commands';\n  group = 'collaborate';\n\n  options: CommandOptions = [];\n  commands: Command[] = [];\n\n  constructor(\n    private workspace: Workspace,\n    private logger: Logger\n  ) {}\n\n  async report() {\n    return { code: 1, data: '[ci] not implemented' };\n  }\n}\n"],"mappings":";;;;;;;;;AAIO,MAAMA,KAAK,CAAoB;EAQpCC,WAAWA,CACDC,SAAoB,EACpBC,MAAc,EACtB;IAAA,KAFQD,SAAoB,GAApBA,SAAoB;IAAA,KACpBC,MAAc,GAAdA,MAAc;IAAAC,eAAA,eATjB,kBAAkB;IAAAA,eAAA,sBACX,aAAa;IAAAA,eAAA,gBACnB,aAAa;IAAAA,eAAA,kBAEK,EAAE;IAAAA,eAAA,mBACN,EAAE;EAKrB;EAEH,MAAMC,MAAMA,CAAA,EAAG;IACb,OAAO;MAAEC,IAAI,EAAE,CAAC;MAAEC,IAAI,EAAE;IAAuB,CAAC;EAClD;AACF;AAACC,OAAA,CAAAR,KAAA,GAAAA,KAAA","ignoreList":[]}
+{"version":3,"names":["CiCmd","constructor","workspace","logger","_defineProperty","report","code","data","exports"],"sources":["ci.cmd.ts"],"sourcesContent":["import type { Command, CommandOptions } from '@teambit/cli';\nimport type { Logger } from '@teambit/logger';\nimport type { Workspace } from '@teambit/workspace';\n\nexport class CiCmd implements Command {\n  name = 'ci <sub-command>';\n  description = 'continuous integration commands for automated workflows';\n  extendedDescription =\n    'provides commands designed for use in CI/CD pipelines with Git workflows to automate component development tasks like verification, pull request handling, and deployment preparation.';\n  group = 'collaborate';\n\n  options: CommandOptions = [];\n  commands: Command[] = [];\n\n  constructor(\n    private workspace: Workspace,\n    private logger: Logger\n  ) {}\n\n  async report() {\n    return { code: 1, data: '[ci] not implemented' };\n  }\n}\n"],"mappings":";;;;;;;;;AAIO,MAAMA,KAAK,CAAoB;EAUpCC,WAAWA,CACDC,SAAoB,EACpBC,MAAc,EACtB;IAAA,KAFQD,SAAoB,GAApBA,SAAoB;IAAA,KACpBC,MAAc,GAAdA,MAAc;IAAAC,eAAA,eAXjB,kBAAkB;IAAAA,eAAA,sBACX,yDAAyD;IAAAA,eAAA,8BAErE,wLAAwL;IAAAA,eAAA,gBAClL,aAAa;IAAAA,eAAA,kBAEK,EAAE;IAAAA,eAAA,mBACN,EAAE;EAKrB;EAEH,MAAMC,MAAMA,CAAA,EAAG;IACb,OAAO;MAAEC,IAAI,EAAE,CAAC;MAAEC,IAAI,EAAE;IAAuB,CAAC;EAClD;AACF;AAACC,OAAA,CAAAR,KAAA,GAAAA,KAAA","ignoreList":[]}

package/dist/ci.docs.mdx

@@ -83,18 +83,51 @@ Publishes new semantic versions after a PR merges to `main`.
 bit ci merge [--message <string>] [--build] [--increment <level>] [--patch|--minor|--major] [--increment-by <number>]
 ```
 
-| Flag              | Shorthand | Description                                                                                                         |
-| ----------------- | --------- | ------------------------------------------------------------------------------------------------------------------- |
-| `--message`       | `-m`      | Changelog entry (defaults to last Git commit message).                                                              |
-| `--build`         | `-b`      | Build locally (otherwise Ripple-CI does it). Required if workspace contains _soft-tagged_ components.               |
-| `--strict`        | `-s`      | Fail on warnings as well as errors (default: only fails on errors).                                                 |
-| `--increment`     | `-l`      | Version bump level: `major`, `premajor`, `minor`, `preminor`, `patch`, `prepatch`, `prerelease` (default: `patch`). |
-| `--patch`         | `-p`      | Shortcut for `--increment patch`.                                                                                   |
-| `--minor`         |           | Shortcut for `--increment minor`.                                                                                   |
-| `--major`         |           | Shortcut for `--increment major`.                                                                                   |
-| `--pre-release`   |           | Shortcut for `--increment prerelease` with optional identifier.                                                     |
-| `--prerelease-id` |           | Prerelease identifier (e.g. "dev" to get "1.0.0-dev.1").                                                            |
-| `--increment-by`  |           | Increment by more than 1 (e.g. `--increment-by 2` with patch: 0.0.1 → 0.0.3).                                       |
+| Flag                   | Shorthand | Description                                                                                                         |
+| ---------------------- | --------- | ------------------------------------------------------------------------------------------------------------------- |
+| `--message`            | `-m`      | Changelog entry (defaults to last Git commit message).                                                              |
+| `--build`              | `-b`      | Build locally (otherwise Ripple-CI does it). Required if workspace contains _soft-tagged_ components.               |
+| `--strict`             | `-s`      | Fail on warnings as well as errors (default: only fails on errors).                                                 |
+| `--increment`          | `-l`      | Version bump level: `major`, `premajor`, `minor`, `preminor`, `patch`, `prepatch`, `prerelease` (default: `patch`). |
+| `--patch`              | `-p`      | Shortcut for `--increment patch`.                                                                                   |
+| `--minor`              |           | Shortcut for `--increment minor`.                                                                                   |
+| `--major`              |           | Shortcut for `--increment major`.                                                                                   |
+| `--pre-release`        |           | Shortcut for `--increment prerelease` with optional identifier.                                                     |
+| `--prerelease-id`      |           | Prerelease identifier (e.g. "dev" to get "1.0.0-dev.1").                                                            |
+| `--increment-by`       |           | Increment by more than 1 (e.g. `--increment-by 2` with patch: 0.0.1 → 0.0.3).                                       |
+| `--auto-tag-increment` |           | Version bump level for auto-tagged dependents. See below.                                                           |
+
+### Bumping Dependents
+
+The version flags above apply only to the components that actually changed. Dependents that are
+picked up by auto-tag are bumped by a `patch`, regardless of `--major`/`--minor`:
+
+```bash
+# button 1.0.0 -> 2.0.0, but its dependent lib 1.0.0 -> 1.0.1
+bit ci merge --major
+```
+
+The one exception is a pre-release `--increment` (`prepatch`, `prerelease`, `preminor`,
+`premajor`), which the dependents do follow:
+
+```bash
+# button 1.0.0 -> 1.0.1-0, and its dependent lib 1.0.0 -> 1.0.1-0 too
+bit ci merge --increment prerelease
+```
+
+Use `--auto-tag-increment` to bump the dependents by an explicit level instead. It overrides both
+defaults above:
+
+```bash
+# button 1.0.0 -> 2.0.0, and its dependent lib 1.0.0 -> 2.0.0 as well
+bit ci merge --major --auto-tag-increment major
+```
+
+The two levels are independent, so `--major --auto-tag-increment minor` is also valid.
+
+**Note**: auto-tag is transitive — a dependent of a dependent is auto-tagged too. So
+`--auto-tag-increment major` bumps the _entire_ dependents graph by a major, not just the direct
+dependents. It cannot be combined with `--skip-auto-tag`.
 
 ### Automatic Version Bump Detection
 
@@ -113,7 +146,7 @@ When **no explicit version flags** are provided, `bit ci merge` can automaticall
 
 3. **Default**: patch version bump
 
-**Note**: Auto-detection only occurs when no version flags (`--patch`, `--minor`, `--major`, etc.) are provided. Explicit flags always take precedence.
+**Note**: Auto-detection only occurs when no version flags (`--patch`, `--minor`, `--major`, etc.) are provided. Explicit flags always take precedence. `--auto-tag-increment` is not considered a version flag for this purpose — it only affects dependents, so it can be combined with auto-detection.
 
 ### Internal flow
 

package/dist/ci.main.runtime.d.ts

@@ -9,6 +9,7 @@ import type { SnappingMain } from '@teambit/snapping';
 import { type ExportMain } from '@teambit/export';
 import { type ImporterMain } from '@teambit/importer';
 import { type CheckoutMain } from '@teambit/checkout';
+import type { MergeStrategy } from '@teambit/component.modules.merge-helper';
 import type { ReleaseType } from 'semver';
 export interface CiWorkspaceConfig {
     /**
@@ -96,36 +97,191 @@ export declare class CiMain {
         CheckoutMain
     ], config: CiWorkspaceConfig): Promise<CiMain>;
     getBranchName(): Promise<string>;
+    /**
+     * Converts a branch name to a lane ID string using Bit's naming conventions.
+     * Sanitizes branch name by replacing slashes and dots with dashes, converting to lowercase, then
+     * prefixes with the workspace's default scope.
+     *
+     * @param branchName - The git branch name to convert
+     * @returns Lane ID in format: {defaultScope}/{sanitizedBranch}
+     * @example convertBranchToLaneId("feature/New-Component") => "my-scope/feature-new-component"
+     */
+    convertBranchToLaneId(branchName: string): string;
     getDefaultBranchName(): Promise<string>;
     getGitCommitMessage(): Promise<string | null>;
     private parseVersionBumpFromCommit;
     private getCustomCommitMessage;
     private verifyWorkspaceStatusInternal;
+    /**
+     * Returns the caught Error on failure, or undefined on success (including the "already checked
+     * out" no-op case). Callers that need to react to a specific failure mode (e.g. stale lane) can
+     * inspect the returned error; existing callers ignore it and rely on a follow-up
+     * `getCurrentLane()` check.
+     */
     private switchToLane;
+    /**
+     * Sync *config-only* changes from main onto the lane — without a full `bit lane merge`.
+     *
+     * In this workflow git is the source of truth for files: the PR author merges the default branch
+     * into their PR branch, so source changes arrive via git. The one thing git can't carry is
+     * config that's already been *tagged into objects* on main — e.g. another PR ran `bit env set` /
+     * `bit deps set`; those records lived in `.bitmap`, rode git into main, and `bit ci merge` baked
+     * them into the component's Version (clearing them from `.bitmap`). A long-running PR's lane
+     * would otherwise miss them.
+     *
+     * A full lane merge is the wrong tool here: it does a 3-way *file* merge and refuses to run while
+     * the workspace has modified components — but in `bit ci pr` the workspace is always dirty (the
+     * PR's changes, not yet snapped). So instead we do a per-component 3-way merge of the aspect
+     * *config only* (base = common ancestor, ours = lane, theirs = main), keeping the PR's config on
+     * conflict, and stash the result on an `unmergedComponents` entry's `mergedConfig`. The
+     * subsequent `snap` reads it (via the aspects-merger on component load) and bakes main's config
+     * into the new snap, while the snap's files still come from the workspace (git). No file
+     * checkout, so no clean-workspace requirement.
+     */
+    private syncConfigFromMain;
+    /**
+     * Batch-fetch main-side Version objects the config merge needs (heads, then common ancestors),
+     * mirroring the lane-merge flows (merge-status-provider / merge-lanes). Best-effort: a fetch
+     * hiccup shouldn't abort `bit ci pr` — the merge loop still runs and any component whose object is
+     * still missing just logs the existing per-component skip. `label` names which objects for the log.
+     */
+    private prefetchFromMainForConfigSync;
+    /**
+     * Copied from `merging.main.runtime` (`filterDeletedDependenciesFromConfig`): the config merge
+     * can emit deletion markers (`version: '-'`) for deps removed on main. The aspects-merger applies
+     * `mergedConfig` verbatim, so strip those here to avoid writing a policy entry with version '-'.
+     */
+    private filterDeletedDependenciesFromConfig;
+    /**
+     * Best-effort, fetch-free check for whether the current (PR) branch is *behind* the default
+     * branch — i.e. the default branch has commits the PR branch doesn't contain.
+     *
+     * We intentionally do NOT `git fetch` here (a fetch in CI can hang on an interactive SSH
+     * host-key prompt — that's why `isStaleCiRun` was removed in #10300). We compare against
+     * whatever `origin/<default>` ref the checkout already has, which reflects the state the default
+     * branch was in when this CI run started — exactly the reference point we care about.
+     *
+     * Returns true only when we can *confirm* the branch is behind. If the ref can't be resolved or
+     * anything else goes wrong, returns false (treat as "not behind" / proceed) so we never silently
+     * disable the main→lane config propagation.
+     */
+    private isBranchBehindDefaultBranch;
     verifyWorkspaceStatus(): Promise<{
         code: number;
         data: string;
     }>;
-    snapPrCommit({ laneIdStr, message, build, strict, }: {
+    snapPrCommit({ laneIdStr, message, build, strict, dryRun, keepLane, skipCleanup, skipTasks, }: {
         laneIdStr: string;
         message: string;
         build: boolean | undefined;
         strict: boolean | undefined;
-    }): Promise<"No changes detected, nothing to snap" | undefined>;
-    mergePr({ message: argMessage, build, strict, releaseType, preReleaseId, incrementBy, explicitVersionBump, verbose, versionsFile, }: {
+        dryRun?: boolean;
+        keepLane?: boolean;
+        skipCleanup?: boolean;
+        skipTasks?: string;
+    }): Promise<string | undefined>;
+    /**
+     * Post-export cleanup: restore the workspace to the original lane / main so an interactive
+     * `bit ci pr` leaves you where you started. `switchToLane('main')` re-checks-out main's HEAD,
+     * which re-imports every workspace component — on a large monorepo that's minutes of work for a
+     * workspace that, in CI, is thrown away the moment the command exits. Hence `skipCleanup`.
+     * Wrapped so a restore failure only warns instead of throwing out of the caller's `finally` and
+     * masking the real error from snap/export. Returns whether the switch actually ran (callers use
+     * it to decide whether follow-up lane bookkeeping that assumes we left the lane is safe).
+     */
+    private restoreWorkspaceAfterPr;
+    /**
+     * `--keep-lane` flow: reuse the existing remote lane (or create it on the first run), merge main
+     * into it to pick up config changes that landed since the fork, snap, and export with
+     * adopt-on-conflict recovery for concurrent CI pushes. The lane object is preserved across PR
+     * commits, so its history and lane-based UI edits on Bit Cloud survive.
+     */
+    private snapAndExportReusingLane;
+    /**
+     * Default flow: snap onto a uniquely-named temporary lane, then at export time delete any
+     * existing remote lane and rename the temp lane to the final name. The temp name minimizes the
+     * race window when multiple CI jobs run concurrently on the same branch. Trade-off: the final
+     * lane is recreated on every PR commit, so its history and any lane-based UI edits on Bit Cloud
+     * don't survive across commits — use `--keep-lane` for that.
+     */
+    private snapAndExportWithTempLane;
+    /**
+     * Export with a recovery path for the two concurrent-CI conflicts that can surface from the
+     * remote (see the marker constants at the top of the file): lane-hash mismatch (both runners
+     * created fresh lane objects when the lane didn't yet exist on the remote) and per-component
+     * divergence (both reused the existing lane but snapped the same component with different
+     * content).
+     *
+     * Recovery: adopt-the-winner. The remote lane (whoever pushed first) becomes canonical. We
+     * drop our local lane object, fetch the remote, rebase our snapped Version objects so each
+     * one's parent points to the remote head for that component, then swap those rebased Versions
+     * in as the new lane heads and re-export. Build artifacts are preserved — only the parent
+     * pointers on the Version objects change. Result: both runners' snaps end up chained on a
+     * single lane object (last-writer-wins on content for any contested component, with the
+     * winner's snap preserved in history as the parent).
+     */
+    private exportWithAdoptOnConflict;
+    /**
+     * Wrap `exporter.export()` with retry on the "server is busy" error. The retried export's
+     * pending-dir lands behind whichever concurrent client is still in the remote's queue (we
+     * arrived second by definition — we're the loser of the original race). The 60s wait inside
+     * `export-validate.waitIfNeeded` covers the common case, but on slow CI hosts or large pushes
+     * we sometimes time out before the other client finishes its persist. A short sleep + retry
+     * here just gives the queue room to drain.
+     */
+    private exportWithBusyRetry;
+    private rebaseOntoRemoteLane;
+    mergePr({ message: argMessage, build, strict, releaseType, autoTagReleaseType, preReleaseId, incrementBy, explicitVersionBump, verbose, versionsFile, autoMergeResolve, forceTheirs, laneName, skipPush, noBitmapCommit, }: {
         message?: string;
         build?: boolean;
         strict?: boolean;
         releaseType: ReleaseType;
+        autoTagReleaseType?: ReleaseType;
         preReleaseId?: string;
         incrementBy?: number;
         explicitVersionBump?: boolean;
         verbose?: boolean;
         versionsFile?: string;
+        autoMergeResolve?: MergeStrategy;
+        forceTheirs?: boolean;
+        laneName?: string;
+        skipPush?: boolean;
+        noBitmapCommit?: boolean;
     }): Promise<{
         code: number;
         data: string;
     }>;
+    /**
+     * Stage every changed file (post-tag/export the bitmap, lockfiles, and any files
+     * touched by `bit checkout head` may differ), commit with the configured message,
+     * rebase against origin, and push — unless `skipPush` was passed.
+     */
+    private commitAndPushBitmapChanges;
+    /**
+     * Compare lane Version extensions with main Version extensions for each component.
+     * Any config differences (e.g. env-set, deps-set) are saved to .bitmap so they survive
+     * the switch from lane to main and get included in the subsequent tag.
+     */
+    private restoreLaneConfigChanges;
+    /**
+     * Performs lane cleanup by attempting to detect and delete the source lane
+     * after a successful merge, even when running on the main branch
+     */
+    private performLaneCleanup;
+    /**
+     * Export with retry on lane hash-mismatch, caused by a concurrent `bit ci pr` run pushing the
+     * same lane id between our pre-export delete and the hub's merge (the export takes 1-2 minutes,
+     * plenty of time to race). Used by the default (temp-lane) flow. On mismatch we delete the
+     * remote lane and retry — the temp-lane flow recreates the lane on every run anyway, so there's
+     * no lane history to preserve. (The `--keep-lane` flow instead adopts the remote lane and
+     * rebases onto it; see `exportWithAdoptOnConflict`.)
+     */
+    private exportWithRetryOnLaneHashMismatch;
+    /**
+     * Archives (deletes) a lane with proper error handling and logging.
+     * @param throwOnError - if true, throws on failure (use for critical operations like pre-export cleanup)
+     */
+    private archiveLane;
     /**
      * Auto-detect version bump from commit messages if no explicit version bump was provided
      */