@goodtek/vibeops 3.1.6 → 3.1.8

package/CHANGELOG.md

@@ -4,6 +4,21 @@ All notable changes to VibeOps are documented here.
 
 ## Unreleased
 
+## 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
+
+- **`task ship --new-cycle` missed work already committed on the task branch** ("Nothing to do — merged with no new changes"). With no uncommitted files it now compares the branch with the fetched `<remote>/<base>` by content (earlier cycles were squash-merged, so commit counts would mislead) and opens the new PR for what is not merged yet (TASK-032).
+- **`-m` was ignored in a new PR cycle**, so the commit used the TASK title and dropped trailers. The new cycle now resolves the message like a normal ship (body and trailers kept); `-m` with nothing to commit warns instead of making an empty commit (TASK-032).
+- **PR body listed other TASKs' changes** after the base branch was merged into the task branch: the Commits / Files lists came from the TASK's Base Commit. They are now computed against the freshly fetched `<remote>/<base>` (commits without merges, files from the merge base); the Base Commit is only a fallback when the fetch fails (TASK-031).
+
 ## 3.1.6 - 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`
@@ -220,8 +221,9 @@ Before calling `gh pr merge` / `glab mr merge`:
 - **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 +235,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 +247,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/commands/task-ship.js

@@ -297,6 +297,8 @@ async function runNewCycleFromShip(ctx) {
         recreateBranch: options.recreateBranch,
         skipLlm: options.skipLlm,
         allowOpenMr: options.allowOpenMr,
+        message: options.message,
+        nonInteractive: options.nonInteractive,
     });
 }
 /** State/PR mismatch: Status is Shipped but no open/merged PR was found. */

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/git.js

@@ -490,8 +490,10 @@ export async function gitAllChangedFilesSinceTaskStart(baseCommit, cwd) {
     const all = Array.from(new Set([...workingTree, ...committed]));
     return { working, staged, untracked, committed, workingTree, all };
 }
-export async function gitLogOneline(cwd, range) {
+export async function gitLogOneline(cwd, range, options = {}) {
     const args = ["log", "--oneline", "--no-decorate"];
+    if (options.noMerges === true)
+        args.push("--no-merges");
     if (typeof range === "string" && range.length > 0)
         args.push(range);
     const res = await tryGit(cwd, args);

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.
  *
@@ -11,7 +17,7 @@ export async function checkBaseInHead(opts) {
     const { cwd, remote, baseBranch, headSha } = opts;
     const baseRef = `refs/remotes/${remote}/${baseBranch}`;
     try {
-        await runGit(cwd, ["fetch", "--no-tags", remote, `+refs/heads/${baseBranch}:${baseRef}`]);
+        await fetchBaseBranch(cwd, remote, baseBranch);
         if (!(await commitExists(cwd, headSha))) {
             await runGit(cwd, ["fetch", "--no-tags", remote, headSha]);
         }

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

@@ -318,20 +318,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;

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/dist/lib/task-new-cycle.js

@@ -1,17 +1,33 @@
 import { resolve } from "node:path";
 import { readText } from "./filesystem.js";
-import { listWorkingTreeRelPaths } from "./git.js";
+import { listWorkingTreeRelPaths, runGit } from "./git.js";
 import { bold, cyan, dim, green, log, yellow } from "./logger.js";
+import { fetchBaseBranch } from "./merge-base-freshness.js";
 import { projectPaths } from "./paths.js";
 import { prNumberFromUrl } from "./pr-create.js";
 import { relPath } from "./task-context.js";
-import { commitDirtyWorkingTree, docsCommitMessageFor, featCommitMessageFor, } from "./task-git-commit.js";
+import { resolveShipCommitMessage } from "./task-commit-msg.js";
+import { commitDirtyWorkingTree, docsCommitMessageFor } from "./task-git-commit.js";
 import { finishTaskWithPullRequest } from "./task-push-pr.js";
 import { applyTaskShipMemory, llmCompleteTaskReship, writeTaskResultSections, } from "./task-ship-llm.js";
 import { assertMergeRequestNotOpen, ensureTaskBranchForReship, integrateIntegrationIntoTaskBranch, loadGitConfigForReship, prepareGitContextForReship, refreshGitContextBaseCommit, resolveReshipTarget, } from "./task-reship.js";
 import { hasNonEmptySection, parseTaskFilename, readGitContext } from "./task.js";
 import { prRefLabel } from "./task-ship-state.js";
 import { runUnderTaskLock } from "./task-lock.js";
+/**
+ * Files this cycle would change on the base: after integrating `<remote>/<base>` the tree
+ * difference to the base is exactly the work not merged yet (earlier cycles' commits were
+ * squash-merged, so counting commits would report them again). With `--no-integrate` the
+ * branch may lack newer base changes, so compare against the merge base instead.
+ */
+async function unmergedFiles(cwd, remote, baseBranch, integrated) {
+    const baseRef = await fetchBaseBranch(cwd, remote, baseBranch);
+    const { stdout } = await runGit(cwd, integrated ? ["diff", "--name-only", baseRef, "HEAD"] : ["diff", "--name-only", `${baseRef}...HEAD`]);
+    return stdout
+        .split("\n")
+        .map((l) => l.trim())
+        .filter((l) => l.length > 0);
+}
 async function commitReshipMetadata(opts) {
     if (opts.dryRun) {
         log.info(dim("  would commit new-cycle metadata (Status stays Shipped)"));
@@ -147,13 +163,39 @@ export async function runPostMergeNewCycle(taskRef, options = {}) {
         process.exitCode = 1;
         return;
     }
+    const parts = parseTaskFilename(taskFile);
     const dirtyBefore = await listWorkingTreeRelPaths(cwd);
-    if (dirtyBefore.length === 0) {
-        log.info(`Nothing to do — ${taskId} is merged with no new changes. Create a new TASK for new work (${cyan("vibeops task add")}).`);
-        return;
+    if (dirtyBefore.length > 0) {
+        const message = await resolveShipCommitMessage({
+            cwd,
+            taskId: parts.id,
+            title: meta.title,
+            provided: options.message,
+            nonInteractive: options.nonInteractive === true,
+        });
+        await commitDirtyWorkingTree(cwd, message, false);
+    }
+    else {
+        // Work may already be committed on the task branch (not merged into the base yet).
+        let pending;
+        try {
+            pending = await unmergedFiles(cwd, remote, integrationBranch, options.noIntegrate !== true);
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message.split("\n")[0] : String(e);
+            log.error(`Could not compare ${taskId}'s branch with ${remote}/${integrationBranch}: ${msg}`);
+            process.exitCode = 1;
+            return;
+        }
+        if (pending.length === 0) {
+            log.info(`Nothing to do — ${taskId} is merged with no new changes. Create a new TASK for new work (${cyan("vibeops task add")}).`);
+            return;
+        }
+        log.info(`No uncommitted changes; ${pending.length} file(s) committed on ${initialCtx.taskBranch} are not on ${remote}/${integrationBranch} yet — opening the PR for them.`);
+        if (options.message?.trim()) {
+            log.warn("-m/--message not used: there is nothing new to commit (existing commits keep their messages).");
+        }
     }
-    const parts = parseTaskFilename(taskFile);
-    await commitDirtyWorkingTree(cwd, featCommitMessageFor(parts.id, meta.title), false);
     let gitCtx = await readGitContext(taskFile);
     if (gitCtx === null) {
         log.error("Git Context missing after commit.");

package/dist/lib/task-push-pr.js

@@ -5,6 +5,7 @@ import { detectGitHost, mergeRequestLabel } from "./git-host.js";
 import { requireGitConfig } from "./git-config.js";
 import { gitCommitsAhead, gitDiffNameOnly, gitLogOneline, gitPush, gitRemoteUrl, readGitInfo, } from "./git.js";
 import { dim, log } from "./logger.js";
+import { fetchBaseBranch } from "./merge-base-freshness.js";
 import { createMergeRequest, findMergeRequestByBranches, probeMergeRequestCli, } from "./pr-create.js";
 import { fallbackTaskPr, generateTaskPrWithLlm } from "./task-pr-llm.js";
 import { readGitContext, readTaskFile } from "./task.js";
@@ -15,9 +16,24 @@ function mergeRequestAlreadyExistsMessage(msg) {
         lower.includes("merge request already exists") ||
         lower.includes("pull request already exists"));
 }
-async function buildDiffSummary(cwd, gitCtx) {
-    const files = await gitDiffNameOnly(cwd, `${gitCtx.baseCommit}..HEAD`);
-    const commits = await gitLogOneline(cwd, `${gitCtx.baseCommit}..HEAD`);
+/**
+ * What the MR/PR changes is measured from the freshly fetched `<remote>/<base>`, not the
+ * TASK's Base Commit: after the base is merged into the task branch (required by the
+ * stale-base check), `<Base Commit>..HEAD` also contains other TASKs' commits. Falls back
+ * to the Base Commit only when the base branch cannot be fetched.
+ */
+async function resolveDiffBase(cwd, remote, gitCtx) {
+    try {
+        return await fetchBaseBranch(cwd, remote, gitCtx.baseBranch);
+    }
+    catch {
+        log.warn(`Could not fetch ${remote}/${gitCtx.baseBranch} — listing changes since the TASK's Base Commit.`);
+        return gitCtx.baseCommit;
+    }
+}
+async function buildDiffSummary(cwd, base) {
+    const files = await gitDiffNameOnly(cwd, `${base}...HEAD`);
+    const commits = await gitLogOneline(cwd, `${base}..HEAD`, { noMerges: true });
     const lines = [];
     if (commits.length > 0) {
         lines.push("Commits:");
@@ -63,7 +79,8 @@ export async function finishTaskWithPullRequest(opts) {
     if (git.branch !== gitCtx.taskBranch) {
         log.warn(`Current branch is ${git.branch ?? "(detached)"}, not ${gitCtx.taskBranch}. Push may fail.`);
     }
-    const ahead = await gitCommitsAhead(opts.cwd, gitCtx.baseCommit, "HEAD");
+    const diffBase = await resolveDiffBase(opts.cwd, gitCfg.remote, gitCtx);
+    const ahead = await gitCommitsAhead(opts.cwd, diffBase, "HEAD");
     if (ahead === 0) {
         log.warn("No commits ahead of base — pushing branch anyway.");
     }
@@ -113,7 +130,7 @@ export async function finishTaskWithPullRequest(opts) {
     const preference = config?.llm?.provider ?? "auto";
     const meta = await readTaskFile(opts.taskFile);
     const taskBody = await readText(opts.taskFile);
-    const diffSummary = await buildDiffSummary(opts.cwd, gitCtx);
+    const diffSummary = await buildDiffSummary(opts.cwd, diffBase);
     const prInput = {
         taskId: meta.id,
         title: meta.title,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodtek/vibeops",
-  "version": "3.1.6",
+  "version": "3.1.8",
   "description": "Minimal CLI rails for Cursor-based TASK-driven vibe coding.",
   "type": "module",
   "packageManager": "pnpm@9.15.9",