@goodtek/vibeops 3.1.5 → 3.1.6

package/CHANGELOG.md

@@ -4,6 +4,13 @@ All notable changes to VibeOps are documented here.
 
 ## Unreleased
 
+## 3.1.6 - 2026-10-17
+
+### Fixed
+
+- **`task release` failed when the release PR was already open.** It now reuses the open integration → production PR; a failing lookup refuses. The dry-run now says the merge waits for the PR's own CI runs (it already did since 3.1.2) and shows `requiredChecks` as an extra by-name list (TASK-030).
+- **An unreadable Git Context was skipped quietly.** `task ship` printed "push/MR skipped" and exited 0; it now exits 1 before committing or pushing and names the problem (e.g. ``line 160 is `## ## Git Context` ``). `task add` no longer "resumes" an In Progress TASK whose Git Context is damaged — that wrote a second section and blocked new TASKs in every worktree (TASK-030).
+
 ## 3.1.5 - 2026-10-16
 
 ### Fixed

package/README.md

@@ -158,7 +158,7 @@ vibeops llm use auto   # auto | codex-oauth | cursor-agent | openai
 - **`task merge`**: merge MR/PR into integration (TASK md unchanged) — **only when every check is green** (see [Merge gate](#merge-gate)).
 - **`task sync`**: verify merge → leave the task branch (switch to integration, or detach at `<remote>/<integration>` when another worktree owns it) → fast-forward local integration where safe → delete local + remote `task/*` branch (TASK md unchanged).
 - **`pull`**: fetch + switch to integration branch + `git pull --ff-only` (one command). Refuses (exit 1) when another worktree has the integration branch checked out — run it there.
-- **`task release`**: integration → production PR + merge (skipped on trunk policy).
+- **`task release`**: integration → production PR + merge (skipped on trunk policy). Reuses the open release PR when there is one; the merge waits for that PR's own CI like `task merge`.
 - **`status`**: Now / Next card — focus stage, checklist, PR, and the next command to run.
 - No force-push to shared branches.
 
@@ -223,6 +223,7 @@ Before calling `gh pr merge` / `glab mr 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).
 - **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).
 
 ### Configuration (`.vibeops.json` → `merge`)

package/dist/commands/task-add.js

@@ -12,7 +12,7 @@ import { findBlockingTask, relPath } from "../lib/task-context.js";
 import { allocateTaskId, TaskIdAllocationError } from "../lib/task-id-allocation.js";
 import { readTaskLockConfig, TaskLockConfigError, TaskLockHeldError, withTaskLock, } from "../lib/task-lock.js";
 import { isIncompleteTaskStart, startTaskBranch } from "../lib/task-start.js";
-import { branchNameForTaskFile, loadActionableTasks, readGitContext } from "../lib/task.js";
+import { branchNameForTaskFile, damagedGitContext, loadActionableTasks, readGitContext, } from "../lib/task.js";
 async function loadGitConfigOrNull(root, dryRun) {
     try {
         return await requireGitConfig(root);
@@ -98,6 +98,15 @@ export async function taskAddCommand(opts = {}) {
         const blocking = await findBlockingTask(paths, root);
         // Resume: In Progress file exists but task branch / Git Context was never finished.
         if (blocking !== null && gitCfg !== null) {
+            // A damaged Git Context is not an unfinished add: resuming would write a second section.
+            const damaged = await damagedGitContext(blocking.filePath);
+            if (damaged !== null) {
+                log.error(`${bold(blocking.id)} is In Progress but its Git Context cannot be read: ${damaged}.`);
+                log.info(`  ${dim("file")}   ${relPath(root, blocking.filePath)}`);
+                log.info(dim("No TASK was created. Fix the TASK file (then ship it), and rerun task add."));
+                process.exitCode = 1;
+                return "done";
+            }
             const incomplete = await isIncompleteTaskStart(root, blocking.filePath);
             if (incomplete) {
                 log.warn(`${yellow("Incomplete")} — ${bold(blocking.id)} exists but the task branch was not created.`);

package/dist/commands/task-release.js

@@ -5,7 +5,7 @@ import { formatHostCliHint, formatHostCliMissingMessage } from "../lib/git-host-
 import { detectGitHost, mergeRequestLabel } from "../lib/git-host.js";
 import { gitRemoteUrl } from "../lib/git.js";
 import { bold, dim, log } from "../lib/logger.js";
-import { createMergeRequest, getMergeRequestState, MergeGateError, mergeMergeRequest, probeMergeRequestCli, } from "../lib/pr-create.js";
+import { createMergeRequest, findMergeRequestByBranches, getMergeRequestState, MergeGateError, mergeMergeRequest, probeMergeRequestCli, } from "../lib/pr-create.js";
 import { assertMergeRequestMerged } from "../lib/task-merge-verify.js";
 function resolveReleaseMergeMethod(opts) {
     if (opts.rebase === true)
@@ -65,9 +65,10 @@ export async function taskReleaseCommand(options = {}) {
     if (dryRun) {
         log.info(bold("dry-run — would:"));
         log.info(`  · ${label}: ${integrationBranch} → ${productionBranch}`);
+        log.info(`  · reuse the open ${label} ${integrationBranch} → ${productionBranch} if there is one`);
         if (options.noMerge !== true) {
-            log.info(`  · merge ${label} (${resolveReleaseMergeMethod(options)}) only when all checks are green`);
-            log.info(`  · required checks: ${requiredChecks.length > 0 ? requiredChecks.join(", ") : "(none configured)"}`);
+            log.info(`  · merge ${label} (${resolveReleaseMergeMethod(options)}) only when every check on its head commit is green — waits for the ${label}'s own CI runs`);
+            log.info(`  · required checks (by name, in addition): ${requiredChecks.length > 0 ? requiredChecks.join(", ") : "none configured"}`);
             if (mergeCfg.allowNoChecks) {
                 log.info("  · allowNoChecks: true (a release PR with no checks would merge)");
             }
@@ -84,24 +85,46 @@ export async function taskReleaseCommand(options = {}) {
         return;
     }
     let releaseUrl;
+    let open;
     try {
-        const { url } = await createMergeRequest({
+        open = await findMergeRequestByBranches({
             cwd,
             host,
-            baseBranch: productionBranch,
             headBranch: integrationBranch,
-            title,
-            body,
+            baseBranch: productionBranch,
+            state: "open",
         });
-        releaseUrl = url;
-        log.ok(`${label}: ${url}`);
     }
     catch (e) {
-        const msg = e instanceof Error ? e.message : String(e);
-        log.error(`Could not create release ${label}: ${msg}`);
+        const msg = e instanceof Error ? e.message.split("\n")[0] : String(e);
+        log.error(`Could not look up an open release ${label}: ${msg}`);
         process.exitCode = 1;
         return;
     }
+    if (open !== null) {
+        releaseUrl = open.url;
+        log.ok(`${label} already open — reusing: ${releaseUrl}`);
+    }
+    else {
+        try {
+            const { url } = await createMergeRequest({
+                cwd,
+                host,
+                baseBranch: productionBranch,
+                headBranch: integrationBranch,
+                title,
+                body,
+            });
+            releaseUrl = url;
+            log.ok(`${label}: ${url}`);
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            log.error(`Could not create release ${label}: ${msg}`);
+            process.exitCode = 1;
+            return;
+        }
+    }
     if (options.noMerge === true) {
         log.info(dim("Merge skipped (--no-merge)."));
         return;

package/dist/commands/task-ship.js

@@ -14,7 +14,7 @@ import { runPostMergeNewCycle } from "../lib/task-new-cycle.js";
 import { applyTaskShipMemory, fallbackResultSections, llmCompleteTaskShip, writeTaskResultSections, } from "../lib/task-ship-llm.js";
 import { detectShipPrState, prRefLabel, resolveShipAction, } from "../lib/task-ship-state.js";
 import { finishTaskWithPullRequest } from "../lib/task-push-pr.js";
-import { hasNonEmptySection, parseTaskFilename, readGitContext, readTaskFile, updateInlineStatus, } from "../lib/task.js";
+import { hasNonEmptySection, parseTaskFilename, gitContextProblem, readGitContext, readTaskFile, updateInlineStatus, } from "../lib/task.js";
 import { assertTaskIdFreeOnRemote } from "../lib/task-id-allocation.js";
 function describePushFailure(message) {
     const lower = message.toLowerCase();
@@ -111,6 +111,13 @@ async function runFirstShip(ctx) {
         process.exitCode = 1;
         return;
     }
+    const gitCtx = await readGitContext(taskFile);
+    if (gitCtx === null) {
+        log.error(`No Git Context in ${relPath(cwd, taskFile)}: ${await gitContextProblem(taskFile)}. Nothing was committed or pushed.`);
+        log.info(dim("`vibeops task add` writes this section with the task branch; restore it, then rerun task ship."));
+        process.exitCode = 1;
+        return;
+    }
     if (dryRun) {
         log.info(bold("dry-run — would:"));
         if (!resultOk || !testOk) {
@@ -128,8 +135,7 @@ async function runFirstShip(ctx) {
         });
         return;
     }
-    const gitCtx = await readGitContext(taskFile);
-    if (gitCtx !== null && !(await ensureOnTaskBranch(cwd, gitCtx, dryRun))) {
+    if (!(await ensureOnTaskBranch(cwd, gitCtx, dryRun))) {
         process.exitCode = 1;
         return;
     }
@@ -150,10 +156,6 @@ async function runFirstShip(ctx) {
         });
         await commitDirtyWorkingTree(cwd, message, false);
     }
-    if (gitCtx === null) {
-        log.info(dim("No Git Context — push/MR skipped."));
-        return;
-    }
     await commitShipMetadata({ cwd, taskFile, taskId: parts.id, dryRun: false });
     const prResult = await finishTaskWithPullRequest({
         cwd,
@@ -183,7 +185,7 @@ async function runUpdateOpenPr(ctx) {
     const { cwd, taskId, taskFile, meta, body, prCtx, dryRun, nonInteractive, options } = ctx;
     const gitCtx = await readGitContext(taskFile);
     if (gitCtx === null) {
-        log.error("No Git Context — cannot update the open PR.");
+        log.error(`No Git Context — cannot update the open PR: ${await gitContextProblem(taskFile)}.`);
         process.exitCode = 1;
         return;
     }

package/dist/lib/task.js

@@ -221,6 +221,25 @@ function locateSection(text, title, level = 2) {
     }
     return null;
 }
+/**
+ * A line that looks like the `## <title>` heading but is not one (e.g. `## ## Git Context`
+ * or `#Git Context`), when no well-formed heading exists. 1-based line number, or `null`.
+ */
+export function findMalformedSectionHeading(text, title, level = 2) {
+    if (locateSection(text, title, level) !== null)
+        return null;
+    const want = title.toLowerCase();
+    const lines = text.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (!/^\s*#/.test(line))
+            continue;
+        const name = line.replace(/^[\s#]+/, "").replace(/[\s#]+$/, "").toLowerCase();
+        if (name === want)
+            return { line: i + 1, text: line.trim() };
+    }
+    return null;
+}
 export function readSection(body, title) {
     const block = locateSection(body, title);
     if (block === null)
@@ -420,6 +439,30 @@ export async function upsertGitContext(filePath, ctx) {
         await writeText(filePath, updated);
     }
 }
+/**
+ * The Git Context exists but cannot be read (malformed heading, or the section lacks
+ * its fields): the problem text, else `null` (readable, or no section at all).
+ */
+export async function damagedGitContext(filePath) {
+    if ((await readGitContext(filePath)) !== null)
+        return null;
+    const raw = await readText(filePath);
+    const malformed = findMalformedSectionHeading(raw, "Git Context") !== null;
+    const unparsable = readSection(raw, "Git Context").length > 0;
+    return malformed || unparsable ? gitContextProblem(filePath) : null;
+}
+/** Why {@link readGitContext} returned `null` for this file — for error messages. */
+export async function gitContextProblem(filePath) {
+    const raw = await readText(filePath);
+    const bad = findMalformedSectionHeading(raw, "Git Context");
+    if (bad !== null) {
+        return `line ${bad.line} is \`${bad.text}\`, not \`## Git Context\` — fix that heading`;
+    }
+    if (readSection(raw, "Git Context").length === 0) {
+        return "the file has no `## Git Context` section";
+    }
+    return "`## Git Context` lacks Base Branch / Base Commit / Task Branch / Started At";
+}
 const GIT_CTX_RE = {
     baseBranch: /^-\s+Base Branch:\s*`([^`]+)`/m,
     baseCommit: /^-\s+Base Commit:\s*`([^`]+)`/m,

package/package.json

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