@goodtek/vibeops 3.1.6 → 3.1.7

package/CHANGELOG.md

@@ -4,6 +4,14 @@ All notable changes to VibeOps are documented here.
 
 ## Unreleased
 
+## 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/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.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

@@ -7,11 +7,17 @@ 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}`;
     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/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.7",
   "description": "Minimal CLI rails for Cursor-based TASK-driven vibe coding.",
   "type": "module",
   "packageManager": "pnpm@9.15.9",