@goodtek/vibeops 3.1.5 → 3.1.7

package/CHANGELOG.md

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