@teambit/ci 1.0.495 → 1.0.500

package/sync/sync-planner.ts

@@ -29,7 +29,14 @@ export type LaneSyncInput = {
    * with `isSyncAuthoredMessage`, not the loop guard's substring match.
    */
   tipIsSyncCommit: boolean;
+  /**
+   * The branch had real (non-bit) commits before this reconciler touched it — it was adopted, not
+   * manufactured. Can only withhold a delete, never authorize one.
+   */
+  hasIndependentHistory?: boolean;
   conflictLabelPresent: boolean;
+  /** The branch's committed `.bitmap` names a DIFFERENT lane — another lane's claim, never adopted. */
+  branchNamesDifferentLane?: boolean;
   /** @see LaneOwnershipEvidence — consulted only on the "lane is gone" path. */
   ownership: LaneOwnershipEvidence;
 };
@@ -38,13 +45,18 @@ export type LaneSyncInput = {
  * Why a `close-pr` is keeping the branch rather than deleting it. `tip-advanced-during-run` is the one
  * the planner never emits: it is discovered when the executor re-reads the branch just before deleting.
  */
-export type BranchKeepReason = 'unmerged-commits' | 'tip-not-a-sync-commit' | 'tip-advanced-during-run';
+export type BranchKeepReason =
+  | 'unmerged-commits'
+  | 'tip-not-a-sync-commit'
+  | 'tip-advanced-during-run'
+  | 'adopted-branch';
 
 export type LaneSyncAction =
   | { type: 'noop'; reason: string }
   | { type: 'import-lane' }
   | { type: 'export-branch' }
   | { type: 'merge-diverged' }
+  | { type: 'adopt-branch' }
   // Two variants rather than an optional `keepReason` so the type enforces that a keep always says why.
   | { type: 'close-pr'; deleteBranch: true }
   | { type: 'close-pr'; deleteBranch: false; keepReason: BranchKeepReason }
@@ -52,7 +64,7 @@ export type LaneSyncAction =
 
 export function planLaneSync(input: LaneSyncInput): LaneSyncAction {
   const { laneHead, branchExists, lastSyncedHead, hasDevCommits, conflictLabelPresent, ownership } = input;
-  const { tipIsSyncCommit } = input;
+  const { tipIsSyncCommit, hasIndependentHistory, branchNamesDifferentLane } = input;
   if (conflictLabelPresent) {
     return { type: 'noop', reason: 'PR is labeled bit-sync-conflict; resolve and remove the label to resume' };
   }
@@ -60,16 +72,20 @@ export function planLaneSync(input: LaneSyncInput): LaneSyncAction {
     if (!branchExists) return { type: 'noop', reason: 'lane and branch both absent' };
     switch (ownership) {
       case 'own-live':
-        // DELETION NEEDS BOTH HALVES: `.bitmap` attribution alone is not enough — a developer who commits
-        // their own `.bitmap` write (bit create / unexported snap / deps set) looks exactly like
-        // "own-live, nothing above the state commit". The marker can only withhold a deletion, never
-        // authorize one; a false keep is harmless, a false delete destroys the only copy of the work.
-        if (!hasDevCommits && tipIsSyncCommit) return { type: 'close-pr', deleteBranch: true };
-        return {
-          type: 'close-pr',
-          deleteBranch: false,
-          keepReason: hasDevCommits ? 'unmerged-commits' : 'tip-not-a-sync-commit',
-        };
+        // Each check is a separate reason to withhold a delete: dev commits are work that exists
+        // nowhere else; a non-sync tip may be a developer's own `.bitmap` write; an adopted branch's
+        // pre-existing history was never proven disposable. A false keep is harmless, a false delete
+        // destroys the only copy.
+        if (hasDevCommits) {
+          return { type: 'close-pr', deleteBranch: false, keepReason: 'unmerged-commits' };
+        }
+        if (!tipIsSyncCommit) {
+          return { type: 'close-pr', deleteBranch: false, keepReason: 'tip-not-a-sync-commit' };
+        }
+        if (hasIndependentHistory) {
+          return { type: 'close-pr', deleteBranch: false, keepReason: 'adopted-branch' };
+        }
+        return { type: 'close-pr', deleteBranch: true };
       case 'own-merged':
         // No marker conjunction needed: the tip being an ancestor of the default branch is unforgeable
         // proof that deleting loses nothing.
@@ -84,10 +100,14 @@ export function planLaneSync(input: LaneSyncInput): LaneSyncAction {
   if (!branchExists) return { type: 'import-lane' };
   if (!lastSyncedHead) {
     if (hasDevCommits) {
-      return {
-        type: 'halt',
-        reason: 'branch has commits but its .bitmap records no state for this lane; cannot tell which side is newer',
-      };
+      if (branchNamesDifferentLane) {
+        return {
+          type: 'halt',
+          reason: 'branch has commits but its .bitmap names a different lane; cannot tell which side is newer',
+        };
+      }
+      // The lane exists but the pair has no sync history: first contact, not a conflict.
+      return { type: 'adopt-branch' };
     }
     return { type: 'import-lane' };
   }

package/sync/sync-state.spec.ts

@@ -6,6 +6,7 @@ import {
   branchStateFingerprint,
   buildSyncCommitMessage,
   fingerprintIdVersions,
+  oldestCommitIsNonSync,
   hasSyncMarker,
   isSyncAuthoredMessage,
   parseBranchBitmap,
@@ -207,6 +208,38 @@ describe('parseDevCommitCount', () => {
   });
 });
 
+describe('oldestCommitIsNonSync', () => {
+  it('is false for an empty range — no commits at all', () => {
+    expect(oldestCommitIsNonSync('')).to.equal(false);
+  });
+
+  it('is false when the oldest (first, with --reverse) record is bit-authored', () => {
+    // A normal bit-created branch: its own first ledger commit, then a later human dev commit and a
+    // second ledger commit from export-branch — non-sync work, but never the OLDEST record.
+    const log = [LANE_SYNC, 'feat: a later, normal dev commit\n', MAIN_SYNC].join('\x1e');
+    expect(oldestCommitIsNonSync(log)).to.equal(false);
+  });
+
+  it('is true when the oldest (first, with --reverse) record is a genuine, non-sync commit', () => {
+    // Adoption's exact shape: the branch's own first commit was a human's, before bit ever touched it.
+    const log = ['feat: a human created this branch before adoption\n', LANE_SYNC].join('\x1e');
+    expect(oldestCommitIsNonSync(log)).to.equal(true);
+  });
+
+  it('ignores a trailing separator with nothing after it', () => {
+    const log = `${LANE_SYNC}\x1e`;
+    expect(oldestCommitIsNonSync(log)).to.equal(false);
+  });
+
+  // A ledger commit needs the marker AND the Bit-Lane-Head trailer; a human message that merely
+  // quotes [bit-sync] on its own line must still read as independent history (a keep, never a delete).
+  it('is true when the oldest human commit quotes the [bit-sync] marker but has no ledger trailer', () => {
+    const spoof = 'feat: mention our tooling\n\n[bit-sync]\n';
+    const log = [spoof, LANE_SYNC].join('\x1e');
+    expect(oldestCommitIsNonSync(log)).to.equal(true);
+  });
+});
+
 describe('fingerprintIdVersions', () => {
   it('is a single 40-hex token, and stable under reordering', () => {
     // A single token survives being written into a commit trailer; order-stability keeps neither

package/sync/sync-state.ts

@@ -68,6 +68,12 @@ export function branchStateFingerprint(state: BranchBitmapState, laneComponentId
   return fingerprintIdVersions(laneComponentIds.map((id) => `${id}@${state.versions[id] ?? ABSENT_ON_BRANCH}`));
 }
 
+/**
+ * `snapPrCommit`'s return value when there was nothing to snap — its only signal either way. Lives in
+ * this leaf module so `ci.main.runtime.ts` and `lane-sync-executor.ts` share it without a cycle.
+ */
+export const NO_CHANGES_TO_SNAP = 'No changes detected, nothing to snap';
+
 export const LANE_HEAD_TRAILER = 'Bit-Lane-Head';
 /**
  * Marks a commit as machine-generated. Duplicated in the `bit-git-sync` action repo's event router
@@ -94,15 +100,49 @@ export function isSyncAuthoredMessage(message: string): boolean {
   return new RegExp(`^${SYNC_COMMIT_MARKER.replace(/[[\]]/g, '\\$&')}\\r?$`, 'm').test(message);
 }
 
+/** The record separator `hasIndependentHistoryBelowStateCommit`'s `git log --format=%B%x1e` uses. */
+const COMMIT_MESSAGE_RECORD_SEPARATOR = '\x1e';
+
+/**
+ * Whether the OLDEST record of a `git log --reverse --format=%B%x1e` run is NOT bit-authored — i.e. a
+ * human created the branch before this reconciler touched it. Oldest only, not "any": ordinary lane
+ * branches carry real dev commits between ledger commits too, and "any" would misclassify them all.
+ */
+export function oldestCommitIsNonSync(rawLog: string): boolean {
+  const messages = rawLog
+    .split(COMMIT_MESSAGE_RECORD_SEPARATOR)
+    .map((entry) => entry.trim())
+    .filter(Boolean);
+  const oldest = messages[0];
+  return oldest !== undefined && !isLedgerCommitMessage(oldest);
+}
+
+/**
+ * Strict probe for "this is one of our LEDGER commits": the sync marker on its own line AND the
+ * `Bit-Lane-Head` trailer — `buildSyncCommitMessage` always writes both. The deletion guard reads
+ * this instead of `isSyncAuthoredMessage` so a human commit merely quoting `[bit-sync]` still counts
+ * as independent history (a false "human" only ever keeps a branch).
+ */
+export function isLedgerCommitMessage(message: string): boolean {
+  return isSyncAuthoredMessage(message) && new RegExp(`^${LANE_HEAD_TRAILER}: `, 'm').test(message);
+}
+
+/**
+ * Marks `adopt-branch`'s ledger commit. Audit-only — the deletion guard reads the branch's ancestry
+ * instead, since a trailer marks only the one commit it is on and later ledger commits carry none.
+ */
+export const ADOPTION_TRAILER = 'Bit-Adopted';
+
 /**
  * The sync commit's message. Every part is an annotation (audit trail + loop-guard marker); nothing reads
  * it as state — messages are forgeable and rewritten on squash-merge. State comes from `.bitmap`.
  */
-export function buildSyncCommitMessage(laneIdStr: string, laneHead: string): string {
+export function buildSyncCommitMessage(laneIdStr: string, laneHead: string, opts: { adopted?: boolean } = {}): string {
   return [
     `chore(bit-sync): sync lane ${laneIdStr} @ ${laneHead.slice(0, 9)}`,
     '',
     `${LANE_HEAD_TRAILER}: ${laneHead}`,
+    ...(opts.adopted ? [`${ADOPTION_TRAILER}: true`] : []),
     SYNC_COMMIT_MARKER,
   ].join('\n');
 }
@@ -163,6 +203,27 @@ export async function readBranchSyncState(
   return { stateCommit, bitmap, hasDevCommits: parseDevCommitCount(count), tipMessage, tipSha };
 }
 
+/**
+ * Whether `branch`'s committed `.bitmap` is byte-identical (by blob sha) to the one at its merge-base
+ * with the default branch — i.e. the branch never asserted a `.bitmap` change of its own, so whatever
+ * pointer it carries is INHERITED. Compared at the fork point, not the default branch's current tip,
+ * which moves on and would false-block. False on any git error: unreadable must not license adoption.
+ */
+export async function branchBitmapUnchangedSinceFork(branch: string, defaultBranch: string): Promise<boolean> {
+  try {
+    const base = (await git.raw(['merge-base', `origin/${defaultBranch}`, `origin/${branch}`])).trim();
+    if (!base) return false;
+    const [branchBlob, baseBlob] = await Promise.all([
+      git.raw(['rev-parse', `origin/${branch}:./${BIT_MAP}`]),
+      git.raw(['rev-parse', `${base}:./${BIT_MAP}`]),
+    ]);
+    const branchSha = branchBlob.trim();
+    return Boolean(branchSha) && branchSha === baseBlob.trim();
+  } catch {
+    return false;
+  }
+}
+
 /**
  * A file's content at a git ref, or undefined when it isn't there. simple-git's `raw` can resolve with
  * empty output instead of rejecting on a missing path; `:./` keeps the path cwd-relative in case the