@goodtek/vibeops 3.1.7 → 3.1.9

package/CHANGELOG.md

@@ -4,6 +4,19 @@ All notable changes to VibeOps are documented here.
 
 ## Unreleased
 
+## 3.1.9 - 2026-10-17
+
+### Fixed
+
+- **The merge gate was blocked by GitHub's dynamic workflow runs.** A failed Dependabot run on the head commit (`event: dynamic`, `dynamic/dependabot/dependabot-updates`) refused a PR whose CI was green — and such runs cannot be re-run. Dynamic runs and `(dynamic)` check runs are now ignored; a `(dynamic)` check named in `requiredChecks` is still required (D-011, TASK-043).
+
+## 3.1.8 - 2026-10-17
+
+### Changed
+
+- **Time values follow official documentation** (D-009, TASK-033). `merge.waitTimeoutSeconds` default 900 → 21600 (GitHub-hosted job limit; max 432000, the self-hosted limit) — the wait still ends as soon as checks finish. `merge.emptyRollupGraceSeconds` default 30 → 0: name CI outside GitHub Actions in `requiredChecks`. `task merge` / `task release` confirm the merge with one read instead of polling (the merge APIs answer synchronously). `scripts/npm-publish.sh` waits for the registry with back-off and jitter within a few-minute budget.
+- **`vibeops init` makes the integration branch the default branch** of a repository it creates on GitHub (`gh repo edit --default-branch`) or GitLab (project API `default_branch`), so PRs and clones start from `develop`. Existing repositories are not changed; on failure the manual command is printed (TASK-035).
+
 ## 3.1.7 - 2026-10-17
 
 ### Fixed

package/README.md

@@ -141,6 +141,7 @@ vibeops llm use auto   # auto | codex-oauth | cursor-agent | openai
 ## Flags (common)
 
 - **`init`**: `--clients`, `--yes`, `--dry-run`, `--force`, `--git`, `--initial-commit`, `--git-policy gitflow|trunk`, `--integration-branch`, `--production-branch`, `--git-host github|gitlab`, `--allow-no-remote`, `--cwd`
+  When `init` creates the repository on GitHub / GitLab (interactive), it pushes `main` and the integration branch and makes the integration branch (`develop` with the GitFlow preset) the repository's default branch; an existing repository's default branch is not changed.
 - **`task add`**: `--dry-run`, `--non-interactive --idea "…"`
 - **`task del`**: `--dry-run`, `--force`, `--no-remote-delete`, `--no-close-mr`
 - **`task ship`**: `-m/--message`, `--new-cycle`, `--no-commit`, `--dry-run`, `--no-pr`, `--non-interactive`, `--allow-open-mr`, `--no-integrate`, `--recreate-branch`, `--skip-llm`
@@ -217,11 +218,13 @@ Before calling `gh pr merge` / `glab mr merge`:
   - **Expected workflows:** every `.github/workflows/*.yml|yaml` at the head commit whose `on:` triggers `pull_request` for this PR, using GitHub's filter rules — `branches` / `branches-ignore` against the base branch, `paths` / `paths-ignore` against the PR's changed files (first 300, like GitHub), and `types` (a custom list must contain both `opened` and `synchronize`). Disabled workflows are skipped; `pull_request_target`, `workflow_call` and other events are not awaited. Each expected workflow must have a `pull_request` run for the head SHA — until it appears the gate **waits** (`workflow … (pull_request) has not started for <sha> yet`), then refuses at `waitTimeoutSeconds`.
   - **All runs for the head SHA** (any event, latest run per workflow + event) must be `completed` with `success`, `neutral` or `skipped`. A queued / in-progress / waiting run waits; any other conclusion refuses immediately — including `startup_failure` (no jobs, so nothing in the rollup) and `action_required` (fork PR awaiting approval).
   - The Actions API is required: if it cannot be read, the gate keeps waiting (back-off) and refuses at the timeout — it never merges blind.
+- **Dynamic workflows are not CI:** runs GitHub generates on the fly — `event: dynamic`, e.g. `dynamic/dependabot/dependabot-updates`, the jobs that open Dependabot PRs — and check runs suffixed `(dynamic)` are ignored. GitHub documents them as "generated for a specific run and … not stored in your repository's `.github/workflows` directory" ([Dependabot on GitHub Actions runners](https://docs.github.com/en/code-security/dependabot/working-with-dependabot/about-dependabot-on-github-actions-runners)); a failed one says nothing about the commit and cannot be re-run. A `(dynamic)` check named in `requiredChecks` is still required.
 - **GitLab:** the MR head pipeline must be `success` or `skipped`. `failed`, `canceled`, `manual` and unknown statuses refuse; `created` / `pending` / `running` / `scheduled` / … wait.
 - **Host output is verified:** if `gh pr view` lacks or has empty `state`, `mergeable`, `headRefOid`, or `statusCheckRollup` is not a list (GitLab: `state`, `sha`, `merge_status`, `detailed_merge_status`, `head_pipeline`), the merge is refused.
 - **Failed check → refuse immediately** (exit code 1, checks named). **Pending → wait** up to `waitTimeoutSeconds`, then refuse. There is no override flag: fix CI (re-run `task ship`) and rerun `task merge`.
-- **No checks at all → refuse** unless `allowNoChecks: true`. "No checks" means: empty rollup, no GitHub Actions run and no expected workflow for the head commit (GitLab: no pipeline). For CI outside GitHub Actions (commit statuses / check apps), the empty list is re-polled for `emptyRollupGraceSeconds` first; list such checks in `requiredChecks` so the gate waits for them by name.
-- **Waiting** polls the host (`gh pr view` + the Actions REST API) every `pollIntervalSeconds` (default 10 s, the default of `gh pr checks --watch`) until the state changes, bounded by `waitTimeoutSeconds` (default 900 s). Host read errors back off exponentially with jitter (capped at 60 s, GitHub's guidance for rate-limited clients).
+- **No checks at all → refuse** unless `allowNoChecks: true`. "No checks" means: empty rollup, no GitHub Actions run and no expected workflow for the head commit (GitLab: no pipeline). For CI outside GitHub Actions (commit statuses / check apps), list such checks in `requiredChecks` so the gate waits for them by name (`emptyRollupGraceSeconds`, default 0, can re-poll an empty list first).
+- **Waiting** polls the host (`gh pr view` + the Actions REST API) every `pollIntervalSeconds` (default 10 s, the default of `gh pr checks --watch`) until the state changes, bounded by `waitTimeoutSeconds` (default 21600 s, the GitHub-hosted job limit). Host read errors back off exponentially with jitter (capped at 60 s, GitHub's guidance for rate-limited clients).
+- **After the merge:** `gh pr merge` / `glab mr merge` return the result synchronously (GitHub `merged: true`, GitLab `state: "merged"`), so VibeOps reads the PR/MR once to confirm. Not merged at that point (merge queue / auto-merge) is reported, not waited for.
 - **The merge is pinned to the checked commit:** right before merging the gate re-reads the PR head; if it moved, the new head is evaluated from scratch. The merge itself uses `gh pr merge --match-head-commit <sha>` (requires **gh ≥ 2.13.0**) / `glab mr merge --auto-merge=false --sha <sha>` (verified with glab 1.106), so a push between the last check and the merge makes the host refuse. A GitLab `405` re-runs the gate and retries once with the same flags.
 - **Unreadable Git Context stops `task ship` / `task add`:** a TASK file whose `## Git Context` cannot be read (e.g. an edit left `## ## Git Context`) makes `task ship` exit 1 before committing or pushing, naming the line; `task add` refuses to "resume" such a TASK (it would write a second section) and names the file and line.
 - **`task merge` refuses a stale base:** the head commit the gate approved must contain the current `<remote>/<base>` (`git merge-base --is-ancestor`, after fetching the base branch and the head commit). A head that does not — the base moved since the branch was pushed, or the branch was rebuilt on an old base (e.g. `git reset --soft <stale origin/develop>` + commit) — can silently revert work merged into the base since, and a squash merge lands that revert. Bring the branch up to date (`git fetch` + `git merge <remote>/<base>`, test, `task ship`), wait for CI, then rerun `task merge`. A fetch failure refuses (fail closed). `task release` does not apply this check (with merge-commit releases the production branch is normally not an ancestor of the integration branch).
@@ -233,9 +236,9 @@ Before calling `gh pr merge` / `glab mr merge`:
   "merge": {
     "requiredChecks": ["build", "lint*"],
     "releaseRequiredChecks": ["release smoke"],
-    "waitTimeoutSeconds": 900,
+    "waitTimeoutSeconds": 21600,
     "pollIntervalSeconds": 10,
-    "emptyRollupGraceSeconds": 30,
+    "emptyRollupGraceSeconds": 0,
     "allowNoChecks": false
   }
 }
@@ -245,9 +248,9 @@ Before calling `gh pr merge` / `glab mr merge`:
 |-----|---------|---------|---------|
 | `requiredChecks` | `[]` | array of non-empty strings | Checks that must be present and green for `task merge`. A missing one refuses: `required check "X" never ran`. |
 | `releaseRequiredChecks` | `[]` | array of non-empty strings | Same for `task release` (integration → production). Shown by `task release --dry-run`. |
-| `waitTimeoutSeconds` | `900` | integer 1–7200 | Max wait for pending checks. |
-| `pollIntervalSeconds` | `10` | integer 1–300, ≤ timeout | Poll interval while waiting (same default as `gh pr checks --watch`). |
-| `emptyRollupGraceSeconds` | `30` | integer 0–600 | Only when no GitHub Actions workflow is expected: how long an empty check list is re-polled before "no checks" applies (time for external CI to report). |
+| `waitTimeoutSeconds` | `21600` | integer 1–432000 | Upper bound for pending checks. The wait ends as soon as every check finished; the bound only stops a check that never does. Default = the 6-hour job limit of GitHub-hosted runners; self-hosted runners allow up to 5 days ([GitHub Actions limits](https://docs.github.com/actions/reference/limits)). |
+| `pollIntervalSeconds` | `10` | integer ≥ 1, ≤ timeout | Poll interval while waiting (same default as `gh pr checks --watch`). |
+| `emptyRollupGraceSeconds` | `0` | integer ≥ 0, ≤ timeout | Only when no GitHub Actions workflow is expected: how long an empty check list is re-polled before "no checks" applies. Default `0`: name CI outside GitHub Actions in `requiredChecks` so the gate waits for it by name, instead of guessing how long it takes to report. |
 | `allowNoChecks` | `false` | boolean | Merge a PR that has no checks at all (repo without CI). Prints one warning per such merge. |
 
 - Check names are exact (`CheckRun.name` / `StatusContext.context`) or a `*` glob (`"lint*"`, `"* · linux"`). Required checks are GitHub-only; GitLab gates on the head pipeline.

package/dist/commands/init.js

@@ -3,7 +3,7 @@ import { install, printReport } from "../bootstrap/installer.js";
 import { buildConfig, isVibeopsProject, readConfig, writeConfig } from "../lib/config.js";
 import { gitAddAll, gitBranchExists, gitCheckout, gitCommit, gitCreateBranch, gitInit, gitPullFastForwardOnly, gitPush, gitRemoteBranchExists, gitRemoteUrl, gitSetDefaultBranch, gitStatusPorcelain, hasAnyCommit, isGitRepository, } from "../lib/git.js";
 import { formatGitPolicySummary, askGitPolicy, parseGitPolicyArg, resolvePreset } from "../lib/git-policy.js";
-import { ensureOriginRemote } from "../lib/git-remote.js";
+import { ensureOriginRemote, setRemoteDefaultBranch } from "../lib/git-remote.js";
 import { askInitClients, formatClientsList, parseClientsArg, } from "../lib/init-clients.js";
 import { askInput, askYesNo } from "../lib/inquirer-helpers.js";
 import { cyan, dim, green, log, yellow } from "../lib/logger.js";
@@ -272,6 +272,19 @@ export async function initCommand(options = {}) {
                 await gitCheckout(projectRoot, gitConfig.integrationBranch);
                 await gitPush(projectRoot, remoteName, gitConfig.integrationBranch, true);
                 log.ok(`pushed ${gitConfig.integrationBranch} → ${remoteName}`);
+                // A repository init just created defaults to the integration branch, so PRs and
+                // clones start from it; an existing repository's setting is left to its owner.
+                if (remote.created === true) {
+                    if (await setRemoteDefaultBranch(projectRoot, gitConfig.host, gitConfig.integrationBranch)) {
+                        log.ok(`default branch → ${gitConfig.integrationBranch}`);
+                    }
+                    else {
+                        log.warn(`Could not set the default branch to ${gitConfig.integrationBranch}.`);
+                        log.info(dim(gitConfig.host === "gitlab"
+                            ? `  glab api --method PUT projects/:id --raw-field default_branch=${gitConfig.integrationBranch}`
+                            : `  gh repo edit --default-branch ${gitConfig.integrationBranch}`));
+                    }
+                }
             }
             pushedBaseline = true;
         }

package/dist/lib/check-rollup.js

@@ -94,6 +94,15 @@ export function checkNameMatches(name, pattern) {
  * - any pending, or a required check not (yet) present → pending
  * - otherwise green (including "no checks at all" when nothing is required)
  */
+/**
+ * Check runs GitHub suffixes with " (dynamic)" belong to dynamic workflows (see
+ * `isDynamicRun` in github-actions-gate.ts), not to the commit's CI: dropped unless a required
+ * check pattern names them.
+ */
+export function withoutDynamicChecks(checks, requiredChecks = []) {
+    return checks.filter((c) => !(c.kind === "CheckRun" && c.name.endsWith(" (dynamic)")) ||
+        requiredChecks.some((p) => checkNameMatches(c.name, p)));
+}
 export function evaluateCheckGate(checks, requiredChecks = []) {
     const failed = checks.filter((c) => c.verdict === "failed");
     const pending = checks.filter((c) => c.verdict === "pending");

package/dist/lib/git-remote.js

@@ -145,10 +145,33 @@ async function createOnHost(cwd, remote, host, defaultBranch) {
                 await runGit(cwd, ["remote", "rename", "origin", remote]);
             }
         }
-        return { remote, url, host };
+        return { remote, url, host, created: true };
     }
     const url = await createGithubRepo(cwd, name);
-    return { remote, url, host };
+    return { remote, url, host, created: true };
+}
+/**
+ * Make `branch` the host's default branch (official CLIs: `gh repo edit --default-branch`,
+ * cli.github.com/manual/gh_repo_edit; GitLab project API `default_branch` via `glab api`,
+ * docs.gitlab.com/api/projects/#edit-a-project; `:id` placeholder: docs.gitlab.com/cli/api/).
+ * Returns false (caller prints the manual step) when the CLI call fails.
+ */
+export async function setRemoteDefaultBranch(cwd, host, branch) {
+    try {
+        if (host === "gitlab") {
+            await execFileAsync("glab", ["api", "--method", "PUT", "projects/:id", "--raw-field", `default_branch=${branch}`], { cwd, maxBuffer: 1024 * 1024 });
+        }
+        else {
+            await execFileAsync("gh", ["repo", "edit", "--default-branch", branch], {
+                cwd,
+                maxBuffer: 1024 * 1024,
+            });
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
 }
 /**
  * Ensures `origin` (or named remote) exists.

package/dist/lib/github-actions-gate.js

@@ -171,6 +171,17 @@ export async function workflowExpectedForPullRequest(yamlText, ctx) {
     return { expected: true };
 }
 const RUN_PASS = new Set(["success", "neutral", "skipped"]);
+/**
+ * GitHub-generated runs that are not the commit's CI: "dynamic workflows are generated for a
+ * specific run and are not stored in your repository's `.github/workflows` directory" — e.g.
+ * the jobs that generate Dependabot pull requests, `dynamic/dependabot/dependabot-updates`
+ * (docs.github.com/code-security/dependabot/working-with-dependabot/about-dependabot-on-github-actions-runners).
+ * Their result says nothing about the head commit, and a failed one cannot be re-run, so the
+ * gate ignores them (required checks named in `.vibeops.json` are still judged by name).
+ */
+export function isDynamicRun(run) {
+    return run.event === "dynamic" || run.path.startsWith("dynamic/");
+}
 function runPath(run) {
     return run.path.split("@")[0];
 }
@@ -180,11 +191,13 @@ function describeRun(run, detail) {
 /**
  * Latest run per (workflow, event) must be completed and passing; every
  * expected workflow must have a `pull_request` run. Unknown statuses /
- * conclusions fail closed.
+ * conclusions fail closed. Dynamic runs ({@link isDynamicRun}) are ignored.
  */
 export function evaluateActionsRuns(runs, expectedPaths) {
     const latest = new Map();
     for (const run of runs) {
+        if (isDynamicRun(run))
+            continue;
         const key = `${runPath(run)}\u0000${run.event}`;
         const prev = latest.get(key);
         if (prev === undefined || run.id > prev.id)

package/dist/lib/merge-base-freshness.js

@@ -1,4 +1,10 @@
 import { gitIsAncestor, runGit } from "./git.js";
+/** Fetch `<remote>/<baseBranch>` into its remote-tracking ref and return that ref. Throws on failure. */
+export async function fetchBaseBranch(cwd, remote, baseBranch) {
+    const baseRef = `refs/remotes/${remote}/${baseBranch}`;
+    await runGit(cwd, ["fetch", "--no-tags", remote, `+refs/heads/${baseBranch}:${baseRef}`]);
+    return baseRef;
+}
 /**
  * The MR/PR head must contain the current tip of its base branch.
  *
@@ -7,12 +13,6 @@ import { gitIsAncestor, runGit } from "./git.js";
  * into the base since; a squash merge then lands that revert. Fetches the base
  * branch and the head commit first; any fetch / read failure fails closed.
  */
-/** Fetch `<remote>/<baseBranch>` into its remote-tracking ref and return that ref. Throws on failure. */
-export async function fetchBaseBranch(cwd, remote, baseBranch) {
-    const baseRef = `refs/remotes/${remote}/${baseBranch}`;
-    await runGit(cwd, ["fetch", "--no-tags", remote, `+refs/heads/${baseBranch}:${baseRef}`]);
-    return baseRef;
-}
 export async function checkBaseInHead(opts) {
     const { cwd, remote, baseBranch, headSha } = opts;
     const baseRef = `refs/remotes/${remote}/${baseBranch}`;

package/dist/lib/merge-config.js

@@ -1,20 +1,32 @@
 import { join } from "node:path";
 import { readTextOrNull } from "./filesystem.js";
 import { VIBEOPS_CONFIG_FILE } from "./paths.js";
+/**
+ * Job execution limits of GitHub Actions (docs.github.com/actions/reference/limits):
+ * "up to 6 hours" per job on GitHub-hosted runners, "up to 5 days" on self-hosted ones.
+ * A pending check cannot legitimately outlast its job, so these bound the wait.
+ */
+const GITHUB_HOSTED_JOB_LIMIT_SECONDS = 6 * 60 * 60;
+const SELF_HOSTED_JOB_LIMIT_SECONDS = 5 * 24 * 60 * 60;
 export const MERGE_GATE_DEFAULTS = {
     requiredChecks: [],
     releaseRequiredChecks: [],
-    waitTimeoutSeconds: 900,
+    // The wait ends as soon as the host reports every check finished; this only bounds a
+    // check that never finishes. Self-hosted runners: raise it up to the 5-day job limit.
+    waitTimeoutSeconds: GITHUB_HOSTED_JOB_LIMIT_SECONDS,
     // Same default as `gh pr checks --watch --interval` (cli.github.com/manual/gh_pr_checks).
     pollIntervalSeconds: 10,
-    emptyRollupGraceSeconds: 30,
+    // No grace by default: CI outside GitHub Actions is awaited by name via `requiredChecks`
+    // (like required status checks in branch protection), not by guessing how long it takes
+    // to report.
+    emptyRollupGraceSeconds: 0,
     allowNoChecks: false,
 };
-/** Inclusive bounds for the numeric settings (seconds). */
+/** Inclusive bounds for the numeric settings (seconds); cross-checks below keep them ≤ the wait. */
 export const MERGE_GATE_LIMITS = {
-    waitTimeoutSeconds: { min: 1, max: 7_200 },
-    pollIntervalSeconds: { min: 1, max: 300 },
-    emptyRollupGraceSeconds: { min: 0, max: 600 },
+    waitTimeoutSeconds: { min: 1, max: SELF_HOSTED_JOB_LIMIT_SECONDS },
+    pollIntervalSeconds: { min: 1, max: SELF_HOSTED_JOB_LIMIT_SECONDS },
+    emptyRollupGraceSeconds: { min: 0, max: SELF_HOSTED_JOB_LIMIT_SECONDS },
 };
 const KNOWN_KEYS = new Set([
     "requiredChecks",
@@ -91,6 +103,9 @@ export function parseMergeConfig(raw) {
         }
         cfg.allowNoChecks = o.allowNoChecks;
     }
+    if (cfg.emptyRollupGraceSeconds > cfg.waitTimeoutSeconds) {
+        throw new MergeConfigError("`emptyRollupGraceSeconds` must not exceed `waitTimeoutSeconds`.");
+    }
     if (cfg.pollIntervalSeconds > cfg.waitTimeoutSeconds) {
         throw new MergeConfigError("`pollIntervalSeconds` must not exceed `waitTimeoutSeconds`.");
     }

package/dist/lib/plan-codex-auth.js

@@ -156,7 +156,9 @@ export async function refreshCodexOAuthTokens(refreshToken) {
 }
 /**
  * Returns a usable access token, refreshing and persisting to auth.json when
- * the JWT is near expiry (same pattern as Hermes `resolve_codex_runtime_credentials`).
+ * the JWT is near expiry. `skewSeconds` is clock-skew leeway on the `exp` claim:
+ * RFC 7519 §4.1.4 allows "some small leeway, usually no more than a few minutes, to
+ * account for clock skew" (rfc-editor.org/rfc/rfc7519#section-4.1.4); 120 s stays within it.
  */
 export async function resolveCodexOAuthAccessToken(skewSeconds = 120) {
     const loaded = await readAuthPayload();

package/dist/lib/pr-create.js

@@ -1,9 +1,9 @@
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { mergeRequestLabel } from "./git-host.js";
-import { classifyRollup, evaluateCheckGate, formatCheckGateProblems, } from "./check-rollup.js";
+import { classifyRollup, evaluateCheckGate, withoutDynamicChecks, formatCheckGateProblems, } from "./check-rollup.js";
 import { isMergeRequestReadyToMerge, isPipelineActive, pipelineGateState, pipelineStatusFromHost, } from "./merge-request-readiness.js";
-import { evaluateActionsRuns, listExpectedPullRequestWorkflows, listWorkflowRunsForSha, parseGitHubPullUrl, } from "./github-actions-gate.js";
+import { evaluateActionsRuns, isDynamicRun, listExpectedPullRequestWorkflows, listWorkflowRunsForSha, parseGitHubPullUrl, } from "./github-actions-gate.js";
 import { dim, log } from "./logger.js";
 import { checkBaseInHead } from "./merge-base-freshness.js";
 import { MERGE_GATE_DEFAULTS, mergeGateTiming } from "./merge-config.js";
@@ -292,7 +292,10 @@ export async function readMergeRequestDetails(cwd, host, url, options) {
             throw new MergeRequestShapeError("gh", problems);
     }
     const checks = classifyRollup(parsed.statusCheckRollup);
-    const gate = evaluateCheckGate(checks);
+    // Dynamic workflows' check runs are not the commit's CI (see `withoutDynamicChecks`);
+    // required ones are still judged by name in the merge gate.
+    const ciChecks = withoutDynamicChecks(checks);
+    const gate = evaluateCheckGate(ciChecks);
     let pipelineStatus = "none";
     if (gate.state === "red") {
         pipelineStatus = "failed";
@@ -300,7 +303,7 @@ export async function readMergeRequestDetails(cwd, host, url, options) {
     else if (gate.state === "pending") {
         pipelineStatus = "running";
     }
-    else if (checks.length > 0) {
+    else if (ciChecks.length > 0) {
         pipelineStatus = "success";
     }
     const mergeable = parsed.mergeable?.trim().toUpperCase() ?? "";
@@ -318,20 +321,6 @@ export async function readMergeRequestDetails(cwd, host, url, options) {
         baseBranch: parsed.baseRefName ?? null,
     };
 }
-/** Poll host until MR/PR state is merged (or timeout). */
-export async function waitForMergeRequestMerged(cwd, host, url, options = {}) {
-    const timeoutMs = options.timeoutMs ?? 120_000;
-    const intervalMs = options.intervalMs ?? 2_000;
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-        const details = await getMergeRequestDetails(cwd, host, url);
-        if (details?.state === "merged" && details.mergedAt !== null) {
-            return true;
-        }
-        await new Promise((resolve) => setTimeout(resolve, intervalMs));
-    }
-    return false;
-}
 function mergeRequestReadinessFromDetails(details) {
     if (details === null)
         return null;
@@ -354,11 +343,12 @@ export class MergeGateError extends Error {
 }
 function evaluateDetailsGate(details, requiredChecks) {
     if (details.checks !== null) {
-        const gate = evaluateCheckGate(details.checks, requiredChecks);
+        const checks = withoutDynamicChecks(details.checks, requiredChecks);
+        const gate = evaluateCheckGate(checks, requiredChecks);
         return {
             state: gate.state,
             problems: formatCheckGateProblems(gate),
-            noChecks: details.checks.length === 0,
+            noChecks: checks.length === 0,
         };
     }
     const state = pipelineGateState(details.pipelineStatus);
@@ -397,7 +387,7 @@ async function evaluateGitHubActions(cwd, url, details, expectedCache) {
         expected = await listExpectedPullRequestWorkflows(cwd, pr, sha, details.baseBranch);
         expectedCache.set(sha, expected);
     }
-    const runs = await listWorkflowRunsForSha(cwd, pr, sha);
+    const runs = (await listWorkflowRunsForSha(cwd, pr, sha)).filter((r) => !isDynamicRun(r));
     return {
         result: evaluateActionsRuns(runs, expected.map((w) => w.path)),
         runCount: runs.length,

package/dist/lib/task-merge-verify.js

@@ -1,22 +1,21 @@
 import { mergeRequestLabel } from "./git-host.js";
-import { getMergeRequestDetails, waitForMergeRequestMerged, } from "./pr-create.js";
+import { getMergeRequestDetails } from "./pr-create.js";
+/**
+ * Read the MR/PR once after `gh pr merge` / `glab mr merge` returned. Both merge APIs
+ * answer synchronously — GitHub `200` with `merged: true`
+ * (docs.github.com/rest/pulls/pulls#merge-a-pull-request), GitLab the merge request with
+ * `state: "merged"` (docs.gitlab.com/api/merge_requests/#merge-a-merge-request; VibeOps
+ * merges with `--auto-merge=false`) — so there is nothing to poll for. Not merged here
+ * means the host queued it (merge queue / auto-merge): report, do not wait.
+ */
 export async function assertMergeRequestMerged(input) {
     const label = mergeRequestLabel(input.host);
-    if (input.wait !== false) {
-        const merged = await waitForMergeRequestMerged(input.cwd, input.host, input.url);
-        if (!merged) {
-            return {
-                ok: false,
-                message: `${label} merge did not complete (still open or auto-merge pending). Wait for Merged on the host, or rerun \`vibeops task merge\`.`,
-            };
-        }
-    }
     const details = await getMergeRequestDetails(input.cwd, input.host, input.url);
     if (details?.state !== "merged" || details.mergedAt === null) {
         const state = details?.state ?? "unknown";
         return {
             ok: false,
-            message: `${label} is ${state}, not merged into ${input.integrationBranch}. Do not run task sync until the host shows Merged.`,
+            message: `${label} is ${state}, not merged into ${input.integrationBranch} (merge queue or auto-merge pending?). Wait for Merged on the host before task sync, or rerun \`vibeops task merge\`.`,
         };
     }
     return { ok: true };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodtek/vibeops",
-  "version": "3.1.7",
+  "version": "3.1.9",
   "description": "Minimal CLI rails for Cursor-based TASK-driven vibe coding.",
   "type": "module",
   "packageManager": "pnpm@9.15.9",
@@ -62,7 +62,7 @@
   "devDependencies": {
     "@eslint/js": "10.0.1",
     "@types/node": "^20.14.0",
-    "eslint": "10.11.0",
+    "eslint": "10.12.0",
     "tsx": "^4.23.15",
     "typescript": "^5.5.4",
     "typescript-eslint": "8.71.0"