merge-steward 0.5.3 → 0.5.4

package/dist/github/shell-git.d.ts

@@ -1,5 +1,5 @@
 import type { GitOperations, SpeculativeBranchBuilder } from "../interfaces.ts";
-import type { MergeResult, RebaseResult } from "../types.ts";
+import type { MergeResult } from "../types.ts";
 export declare class ShellGitOperations implements GitOperations, SpeculativeBranchBuilder {
     private readonly clonePath;
     private readonly repoFullName;
@@ -9,7 +9,7 @@ export declare class ShellGitOperations implements GitOperations, SpeculativeBra
     fetch(remote?: string): Promise<void>;
     headSha(branch: string): Promise<string>;
     isAncestor(ancestor: string, descendant: string): Promise<boolean>;
-    rebase(branch: string, onto: string): Promise<RebaseResult>;
+    mergeBaseInto(branch: string, base: string): Promise<MergeResult>;
     push(branch: string, force?: boolean): Promise<void>;
     buildSpeculative(prBranch: string, baseBranch: string, specName: string): Promise<MergeResult>;
     deleteSpeculative(specName: string): Promise<void>;

package/dist/github/shell-git.js

@@ -41,24 +41,22 @@ export class ShellGitOperations {
             return false;
         throw new Error(`git merge-base --is-ancestor failed: ${result.stderr || result.stdout}`);
     }
-    async rebase(branch, onto) {
+    async mergeBaseInto(branch, base) {
         const remoteBranchRef = `refs/remotes/origin/${branch}`;
         const remoteBranchExists = await this.git(["show-ref", "--verify", remoteBranchRef], { allowNonZero: true });
         if (remoteBranchExists.exitCode === 0) {
-            // Always start from the freshly fetched remote branch tip so stale local branches
-            // cannot reintroduce old commits into queue processing.
             await this.git(["checkout", "-B", branch, `origin/${branch}`]);
         }
         else {
             await this.git(["checkout", branch]);
         }
-        const result = await this.git(["rebase", onto], { allowNonZero: true });
+        const result = await this.git(["merge", "--no-ff", "--no-edit", base], { allowNonZero: true });
         if (result.exitCode !== 0) {
-            await this.git(["rebase", "--abort"], { allowNonZero: true });
+            await this.git(["merge", "--abort"], { allowNonZero: true });
             return { success: false, conflictFiles: parseConflicts(result.stderr) };
         }
         const newSha = await this.headSha("HEAD");
-        return { success: true, newHeadSha: newSha };
+        return { success: true, sha: newSha };
     }
     async push(branch, force = false) {
         const args = ["push"];

package/dist/interfaces.d.ts

@@ -1,4 +1,4 @@
-import type { CIStatus, CheckResult, IncidentRecord, MergeResult, PRStatus, QueueEntry, RebaseResult } from "./types.ts";
+import type { CIStatus, CheckResult, IncidentRecord, MergeResult, PRStatus, QueueEntry } from "./types.ts";
 /**
  * Git operations needed by the reconciler. The sim (GitSim) implements
  * additional methods for test harness setup, but the reconciler only uses these.
@@ -7,7 +7,7 @@ export interface GitOperations {
     fetch(remote?: string): Promise<void>;
     headSha(branch: string): Promise<string>;
     isAncestor(ancestor: string, descendant: string): Promise<boolean>;
-    rebase(branch: string, onto: string): Promise<RebaseResult>;
+    mergeBaseInto(branch: string, base: string): Promise<MergeResult>;
     push(branch: string, force?: boolean): Promise<void>;
 }
 /**

package/dist/reconciler.js

@@ -71,7 +71,7 @@ export async function reconcile(ctx) {
         }
     }
 }
-// ─── Head entry: fetch + gate + rebase ──────────────────────────
+// ─── Head entry: fetch + gate + branch refresh ──────────────────
 async function prepareHead(ctx, entry) {
     emit(ctx, entry, "fetch_started");
     await ctx.git.fetch();
@@ -116,7 +116,7 @@ async function prepareHead(ctx, entry) {
         emit(ctx, entry, "retry_gated", { baseSha, detail: "base unchanged since last conflict" });
         return;
     }
-    await performRebase(ctx, entry, baseSha);
+    await performBranchRefresh(ctx, entry, baseSha);
 }
 function describeMainBroken(failingChecks, pendingChecks) {
     const parts = [];
@@ -135,9 +135,9 @@ function summarizeCheckNames(checks, limit = 3) {
     }
     return `${names.slice(0, limit).join(", ")} +${names.length - limit} more`;
 }
-async function performRebase(ctx, entry, baseSha) {
+async function performBranchRefresh(ctx, entry, baseSha) {
     emit(ctx, entry, "rebase_started", { baseSha });
-    const result = await ctx.git.rebase(entry.branch, ref(ctx, ctx.baseBranch));
+    const result = await ctx.git.mergeBaseInto(entry.branch, ref(ctx, ctx.baseBranch));
     if (!result.success) {
         emit(ctx, entry, "rebase_conflict", { baseSha, conflictFiles: result.conflictFiles });
         if (isBudgetExhausted(entry)) {
@@ -153,28 +153,17 @@ async function performRebase(ctx, entry, baseSha) {
         }
         return;
     }
-    const headSha = result.newHeadSha ?? entry.headSha;
+    const headSha = result.sha ?? entry.headSha;
     await ctx.git.fetch();
     const latestRemoteHead = await ctx.git.headSha(ref(ctx, entry.branch));
-    const candidateKeepsLatestRemote = await ctx.git.isAncestor(latestRemoteHead, headSha);
-    if (!candidateKeepsLatestRemote) {
-        const detail = latestRemoteHead === entry.headSha
-            ? `candidate diverged from remote head: expected ${entry.headSha.slice(0, 8)}, ` +
-                `latest ${latestRemoteHead.slice(0, 8)}, candidate ${headSha.slice(0, 8)}`
-            : `remote advanced during rebase: expected ${entry.headSha.slice(0, 8)}, ` +
-                `latest ${latestRemoteHead.slice(0, 8)}, candidate ${headSha.slice(0, 8)}`;
+    if (latestRemoteHead !== entry.headSha) {
+        const detail = `remote advanced during refresh: expected ${entry.headSha.slice(0, 8)}, ` +
+            `latest ${latestRemoteHead.slice(0, 8)}, candidate ${headSha.slice(0, 8)}`;
         emit(ctx, entry, "branch_mismatch", { detail });
-        if (latestRemoteHead !== entry.headSha) {
-            ctx.store.updateHead(entry.id, latestRemoteHead);
-        }
-        else {
-            ctx.store.transition(entry.id, "queued", {
-                ...CLEAN_CI,
-            }, `stale local branch diverged from ${latestRemoteHead.slice(0, 8)}`);
-        }
+        ctx.store.updateHead(entry.id, latestRemoteHead);
         return;
     }
-    await ctx.git.push(entry.branch, true);
+    await ctx.git.push(entry.branch, false);
     emit(ctx, entry, "rebase_succeeded", { baseSha });
     // Build speculative branch for downstream entries.
     let specBranch = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "merge-steward",
-  "version": "0.5.3",
+  "version": "0.5.4",
   "description": "Serial merge queue for GitHub — rebase, CI-gate, and merge PRs one at a time",
   "type": "module",
   "repository": {