@goodtek/vibeops 2.4.3 → 2.4.4

package/CHANGELOG.md

@@ -4,6 +4,14 @@ All notable changes to VibeOps are documented here.
 
 ## Unreleased
 
+## 2.4.4 - 2026-06-25
+
+### Fixed
+
+- **`task sync`:** After merge verification passes, delete the local `task/*` branch with `-D`. Squash-merged TASK branches no longer require `--force` for cleanup.
+- **`task merge` / `task release`:** Wait for MR/PR CI to finish before calling the host merge API. GitLab no longer gets an immediate `--auto-merge=false` merge while the pipeline is still running (405). Falls back to auto-merge when needed, then polls until `merged_at` is set.
+- **`task release`:** Default merge strategy is now **merge commit** (integration → production). Use `--squash` to squash.
+
 ## 2.4.3 - 2026-06-25
 
 ### Fixed

package/dist/cli.js

@@ -165,7 +165,7 @@ task
     .description("After MR merge: integration pull and delete task branch (TASK md unchanged)")
     .option("--dry-run", "Plan only")
     .option("--no-remote-delete", "Keep the task branch on the remote")
-    .option("--force", "Bypass MR merge checks and delete local task branch with -D if not fully merged")
+    .option("--force", "Bypass MR merge verification before branch cleanup")
     .option("--cwd <path>", "Target directory")
     .action(async (taskRef, opts) => {
     await taskSyncCommand(taskRef, {
@@ -177,10 +177,11 @@ task
 });
 task
     .command("release")
-    .description("Open (and merge) release MR/PR: integration branch → production")
+    .description("Open (and merge) release MR/PR: integration branch → production (default: merge commit)")
     .option("--dry-run", "Plan only")
     .option("--no-merge", "Create release PR only")
-    .option("--merge", "Merge commit (instead of squash)")
+    .option("--squash", "Squash merge (default is merge commit for release)")
+    .option("--merge", "Merge commit (default for release)")
     .option("--rebase", "Rebase merge")
     .option("--cwd <path>", "Target directory")
     .action(async (opts) => {
@@ -188,6 +189,7 @@ task
         dryRun: Boolean(opts.dryRun),
         noMerge: Boolean(opts.noMerge),
         merge: Boolean(opts.merge),
+        squash: Boolean(opts.squash),
         rebase: Boolean(opts.rebase),
         cwd: opts.cwd,
     });

package/dist/commands/task-merge.js

@@ -102,7 +102,14 @@ export async function taskMergeCommand(taskRef, options = {}) {
             return;
         }
         try {
-            await mergeMergeRequest({ cwd, host, url: mergeRequestUrl, method, immediate: true });
+            await mergeMergeRequest({
+                cwd,
+                host,
+                url: mergeRequestUrl,
+                method,
+                waitForCi: true,
+                immediate: true,
+            });
             const verified = await assertMergeRequestMerged({
                 cwd,
                 host,
@@ -132,7 +139,14 @@ export async function taskMergeCommand(taskRef, options = {}) {
     else {
         log.warn(`Could not read ${label} state — attempting merge anyway.`);
         try {
-            await mergeMergeRequest({ cwd, host, url: mergeRequestUrl, method, immediate: true });
+            await mergeMergeRequest({
+                cwd,
+                host,
+                url: mergeRequestUrl,
+                method,
+                waitForCi: true,
+                immediate: true,
+            });
             const verified = await assertMergeRequestMerged({
                 cwd,
                 host,

package/dist/commands/task-release.js

@@ -5,12 +5,12 @@ import { gitRemoteUrl } from "../lib/git.js";
 import { bold, dim, log } from "../lib/logger.js";
 import { createMergeRequest, getMergeRequestState, mergeMergeRequest, probeMergeRequestCli, } from "../lib/pr-create.js";
 import { assertMergeRequestMerged } from "../lib/task-merge-verify.js";
-function resolveMergeMethod(opts) {
+function resolveReleaseMergeMethod(opts) {
     if (opts.rebase === true)
         return "rebase";
-    if (opts.merge === true)
-        return "merge";
-    return "squash";
+    if (opts.squash === true)
+        return "squash";
+    return "merge";
 }
 export async function taskReleaseCommand(options = {}) {
     const cwd = resolve(options.cwd ?? process.cwd());
@@ -51,7 +51,7 @@ export async function taskReleaseCommand(options = {}) {
         log.info(bold("dry-run — would:"));
         log.info(`  · ${label}: ${integrationBranch} → ${productionBranch}`);
         if (options.noMerge !== true) {
-            log.info(`  · merge ${label} (${resolveMergeMethod(options)})`);
+            log.info(`  · merge ${label} (${resolveReleaseMergeMethod(options)}, wait for CI)`);
         }
         return;
     }
@@ -90,9 +90,16 @@ export async function taskReleaseCommand(options = {}) {
         log.ok(`Release ${label} already merged.`);
         return;
     }
-    const method = resolveMergeMethod(options);
+    const method = resolveReleaseMergeMethod(options);
     try {
-        await mergeMergeRequest({ cwd, host, url: releaseUrl, method, immediate: true });
+        await mergeMergeRequest({
+            cwd,
+            host,
+            url: releaseUrl,
+            method,
+            waitForCi: true,
+            immediate: true,
+        });
         const verified = await assertMergeRequestMerged({
             cwd,
             host,

package/dist/commands/task-sync.js

@@ -61,7 +61,7 @@ export async function taskSyncCommand(taskRef, options = {}) {
         log.info(`  · git fetch ${remote} --prune`);
         log.info(`  · git switch ${integrationBranch}`);
         log.info(`  · git pull --ff-only ${remote} ${integrationBranch}`);
-        log.info(`  · git branch ${options.force === true ? "-D" : "-d"} ${taskBranch}`);
+        log.info(`  · git branch -D ${taskBranch}`);
         if (options.noRemoteDelete !== true) {
             log.info(`  · git push ${remote} --delete ${taskBranch} (if exists)`);
         }
@@ -133,13 +133,15 @@ export async function taskSyncCommand(taskRef, options = {}) {
     log.ok(`Ready to sync — ${integrationBranch} contains the task commits.`);
     if (await gitBranchExists(cwd, taskBranch)) {
         try {
-            await gitDeleteBranch(cwd, taskBranch, { force: options.force === true });
+            // Guard verified integration contains the work — squash merges leave task/* SHAs
+            // off develop ancestry, so -D is required even without --force.
+            await gitDeleteBranch(cwd, taskBranch, { force: true });
             log.ok(`Deleted local branch ${taskBranch}`);
         }
         catch (e) {
             const msg = e instanceof Error ? e.message : String(e);
             log.error(`Could not delete local ${taskBranch}: ${msg}`);
-            log.info(dim("Merge the MR into the integration branch first, or rerun with --force (discards unmerged branch)."));
+            log.info(dim("Merge the MR into the integration branch first, or rerun with --force (skip merge verification)."));
             process.exitCode = 1;
             return;
         }

package/dist/lib/merge-request-readiness.js

@@ -0,0 +1,57 @@
+const ACTIVE_PIPELINE_STATUSES = new Set([
+    "pending",
+    "running",
+    "created",
+    "waiting_for_resource",
+    "preparing",
+]);
+const TERMINAL_PIPELINE_FAILURES = new Set(["failed", "canceled"]);
+function normalizePipelineStatus(raw) {
+    if (raw === null || raw === undefined || raw.trim().length === 0)
+        return "none";
+    const status = raw.trim().toLowerCase();
+    if (status === "success")
+        return "success";
+    if (status === "skipped")
+        return "skipped";
+    if (status === "failed")
+        return "failed";
+    if (status === "canceled" || status === "cancelled")
+        return "canceled";
+    if (ACTIVE_PIPELINE_STATUSES.has(status))
+        return "running";
+    return "unknown";
+}
+export function pipelineStatusFromHost(raw) {
+    return normalizePipelineStatus(raw);
+}
+export function isPipelineActive(status) {
+    return status === "running" || status === "pending";
+}
+/** True when the host reports the MR can be merged now (CI done or not required). */
+export function isMergeRequestReadyToMerge(readiness) {
+    if (readiness.state === "merged")
+        return true;
+    if (readiness.state !== "open")
+        return false;
+    if (readiness.hasConflicts === true)
+        return false;
+    const detailed = readiness.detailedMergeStatus?.trim().toLowerCase() ?? "";
+    if (detailed === "conflict" ||
+        detailed === "not_approved" ||
+        detailed === "draft_status" ||
+        detailed === "ci_still_running" ||
+        detailed === "checking" ||
+        detailed === "not_open" ||
+        detailed === "discussions_not_resolved" ||
+        detailed === "need_rebase" ||
+        detailed === "blocked_status") {
+        return false;
+    }
+    if (TERMINAL_PIPELINE_FAILURES.has(readiness.pipelineStatus))
+        return false;
+    if (isPipelineActive(readiness.pipelineStatus))
+        return false;
+    const mergeStatus = readiness.mergeStatus?.trim().toLowerCase() ?? "";
+    return mergeStatus === "can_be_merged" || detailed === "mergeable";
+}

package/dist/lib/pr-create.js

@@ -1,7 +1,8 @@
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { mergeRequestLabel } from "./git-host.js";
-import { log } from "./logger.js";
+import { isMergeRequestReadyToMerge, isPipelineActive, pipelineStatusFromHost, } from "./merge-request-readiness.js";
+import { dim, log } from "./logger.js";
 const execFileAsync = promisify(execFile);
 async function ghPrCreate(opts) {
     const { stdout } = await execFileAsync("gh", [
@@ -64,6 +65,7 @@ export async function probeMergeRequestCli(host) {
         return false;
     }
 }
+export { isMergeRequestReadyToMerge, isPipelineActive };
 function normalizeGhMergeRequestState(raw) {
     const state = raw.trim().toUpperCase();
     if (state === "MERGED")
@@ -202,15 +204,35 @@ export async function getMergeRequestDetails(cwd, host, url) {
                 mergedAt: parsed.merged_at ?? null,
                 mergeCommitSha: parsed.merge_commit_sha ?? null,
                 squashCommitSha: parsed.squash_commit_sha ?? null,
+                mergeStatus: parsed.merge_status ?? null,
+                detailedMergeStatus: parsed.detailed_merge_status ?? null,
+                pipelineStatus: pipelineStatusFromHost(parsed.head_pipeline?.status),
+                hasConflicts: parsed.has_conflicts ?? null,
             };
         }
-        const { stdout } = await execFileAsync("gh", ["pr", "view", ref, "--json", "state,mergedAt,mergeCommit"], { cwd, maxBuffer: 1024 * 1024 });
+        const { stdout } = await execFileAsync("gh", ["pr", "view", ref, "--json", "state,mergedAt,mergeCommit,mergeable,statusCheckRollup"], { cwd, maxBuffer: 1024 * 1024 });
         const parsed = JSON.parse(stdout.trim());
+        const checks = parsed.statusCheckRollup ?? [];
+        let pipelineStatus = "none";
+        if (checks.some((c) => (c.state ?? "").toUpperCase() === "PENDING")) {
+            pipelineStatus = "running";
+        }
+        else if (checks.some((c) => (c.state ?? "").toUpperCase() === "FAILURE")) {
+            pipelineStatus = "failed";
+        }
+        else if (checks.length > 0) {
+            pipelineStatus = "success";
+        }
+        const mergeable = parsed.mergeable?.trim().toUpperCase() ?? "";
         return {
             state: normalizeGhMergeRequestState(parsed.state ?? ""),
             mergedAt: parsed.mergedAt ?? null,
             mergeCommitSha: parsed.mergeCommit?.oid ?? null,
             squashCommitSha: null,
+            mergeStatus: mergeable === "MERGEABLE" ? "can_be_merged" : mergeable.toLowerCase(),
+            detailedMergeStatus: mergeable.toLowerCase(),
+            pipelineStatus,
+            hasConflicts: mergeable === "CONFLICTING" ? true : mergeable === "MERGEABLE" ? false : null,
         };
     }
     catch {
@@ -231,6 +253,42 @@ export async function waitForMergeRequestMerged(cwd, host, url, options = {}) {
     }
     return false;
 }
+function mergeRequestReadinessFromDetails(details) {
+    if (details === null)
+        return null;
+    return {
+        state: details.state,
+        mergeStatus: details.mergeStatus,
+        detailedMergeStatus: details.detailedMergeStatus,
+        pipelineStatus: details.pipelineStatus,
+        hasConflicts: details.hasConflicts,
+    };
+}
+/** Poll until MR/PR CI finished and host reports mergeable (or already merged). */
+export async function waitForMergeRequestReadyToMerge(cwd, host, url, options = {}) {
+    const timeoutMs = options.timeoutMs ?? 900_000;
+    const intervalMs = options.intervalMs ?? 5_000;
+    const deadline = Date.now() + timeoutMs;
+    const label = mergeRequestLabel(host);
+    let loggedWait = false;
+    while (Date.now() < deadline) {
+        const details = await getMergeRequestDetails(cwd, host, url);
+        const readiness = mergeRequestReadinessFromDetails(details);
+        if (readiness !== null && isMergeRequestReadyToMerge(readiness)) {
+            return true;
+        }
+        if (!loggedWait) {
+            log.info(dim(`Waiting for ${label} pipeline / merge checks…`));
+            loggedWait = true;
+        }
+        await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+    return false;
+}
+function isMergeHttp405(error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return msg.includes("405") || msg.toLowerCase().includes("method not allowed");
+}
 export async function closeMergeRequest(opts) {
     const ref = prRefFromUrl(opts.url);
     const label = mergeRequestLabel(opts.host);
@@ -254,10 +312,19 @@ export async function mergeMergeRequest(opts) {
     const ref = prRefFromUrl(opts.url);
     const method = opts.method ?? "squash";
     const label = mergeRequestLabel(opts.host);
+    if (opts.waitForCi === true && opts.dryRun !== true) {
+        const ready = await waitForMergeRequestReadyToMerge(opts.cwd, opts.host, opts.url);
+        if (!ready) {
+            throw new Error(`${label} is not ready to merge yet (pipeline running, checks pending, or timeout).`);
+        }
+    }
+    const details = await getMergeRequestDetails(opts.cwd, opts.host, opts.url);
+    const readiness = mergeRequestReadinessFromDetails(details);
+    const pipelineActive = readiness !== null ? isPipelineActive(readiness.pipelineStatus) : false;
     if (opts.dryRun === true) {
         if (opts.host === "gitlab") {
-            const immediate = opts.immediate !== false;
-            const flags = immediate ? " --auto-merge=false" : "";
+            const immediate = opts.immediate !== false && !pipelineActive;
+            const flags = immediate ? " --auto-merge=false" : " (auto-merge when pipeline succeeds)";
             const methodFlag = method === "squash" ? " --squash" : method === "rebase" ? " --rebase" : "";
             log.info(`would ${label} merge ${ref} (glab mr merge${flags}${methodFlag})`);
         }
@@ -267,22 +334,46 @@ export async function mergeMergeRequest(opts) {
         return;
     }
     if (opts.host === "gitlab") {
-        const args = ["mr", "merge", ref];
-        if (opts.immediate !== false) {
+        await mergeGitLabMergeRequest({
+            cwd: opts.cwd,
+            ref,
+            method,
+            immediate: opts.immediate !== false && !pipelineActive,
+        });
+        return;
+    }
+    const args = ["pr", "merge", ref, `--${method}`];
+    await execFileAsync("gh", args, { cwd: opts.cwd, maxBuffer: 4 * 1024 * 1024 });
+}
+async function mergeGitLabMergeRequest(input) {
+    const attempt = async (immediate) => {
+        const args = ["mr", "merge", input.ref];
+        if (immediate) {
             args.push("--auto-merge=false");
         }
-        if (method === "squash") {
+        if (input.method === "squash") {
             args.push("--squash");
         }
-        else if (method === "rebase") {
+        else if (input.method === "rebase") {
             args.push("--rebase");
         }
         await execFileAsync("glab", args, {
-            cwd: opts.cwd,
+            cwd: input.cwd,
             maxBuffer: 4 * 1024 * 1024,
         });
-        return;
+    };
+    try {
+        await attempt(input.immediate);
+    }
+    catch (error) {
+        if (!input.immediate && isMergeHttp405(error)) {
+            await attempt(false);
+            return;
+        }
+        if (input.immediate && isMergeHttp405(error)) {
+            await attempt(false);
+            return;
+        }
+        throw error;
     }
-    const args = ["pr", "merge", ref, `--${method}`];
-    await execFileAsync("gh", args, { cwd: opts.cwd, maxBuffer: 4 * 1024 * 1024 });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodtek/vibeops",
-  "version": "2.4.3",
+  "version": "2.4.4",
   "description": "Minimal CLI rails for Cursor-based TASK-driven vibe coding.",
   "type": "module",
   "author": "VibeOps contributors",