@goodtek/vibeops 2.5.0 → 2.5.2

package/CHANGELOG.md

@@ -4,6 +4,19 @@ All notable changes to VibeOps are documented here.
 
 ## Unreleased
 
+## 2.5.2 - 2026-07-20
+
+### Fixed
+
+- **`task add` / integration sync:** Governance-only dirt (`.vibeops.json`, `AGENTS.md`, `.vibeops/`, docs, `.cursor/rules/`) no longer blocks preflight. Right after `init`, `task add` works without stash. App-file dirt still fails and lists the blocking paths.
+
+## 2.5.1 - 2026-07-20
+
+### Fixed
+
+- **`task add`:** Preflight-syncs the integration branch **before** creating a TASK file. On ff-only failure, prints a classified diagnosis (dirty / ahead / diverged) with copy-paste fix commands. Incomplete adds (file created, branch missing) resume on the next `task add` instead of blocking with “finish ship first”.
+- **`vibeops pull`:** Uses the same integration sync diagnosis when `--ff-only` fails.
+
 ## 2.5.0 - 2026-07-19
 
 ### Breaking

package/README.md

@@ -7,21 +7,49 @@
 
 VibeOps bootstraps an **agent-friendly repo**, starts numbered **TASK** files on Git branches, and runs a clear GitFlow lifecycle. You plan and implement in your chosen agent; the CLI handles files, Git, and short LLM assists.
 
+**Current release:** [`@goodtek/vibeops@2.5.1`](https://www.npmjs.com/package/@goodtek/vibeops) — interactive init remote (GitHub/GitLab), state-aware `task ship` only (no `task reship`), `status` Now/Next card, clearer `task add` integration sync errors.
+
 ## Commands
 
 | Command | Purpose |
 |---------|---------|
-| `vibeops init` | Core docs + agent packs (cursor / claude / codex) |
+| `vibeops init` | Core docs + agent packs; interactive Git host + create/connect remote |
 | `vibeops task add` | New `TASK-NNN` file + task branch |
 | `vibeops task del` | Cancel TASK before merge (md + branch + close open MR) |
-| `vibeops task ship` | State-aware submit: open a new PR · update the open PR · start a new PR cycle after merge (Status → **Shipped**) |
+| `vibeops task ship` | State-aware submit: new PR · update open PR · new PR cycle after merge (Status → **Shipped**) |
 | `vibeops task merge` | Merge TASK MR/PR into integration branch (default: squash) |
 | `vibeops task sync` | After merge: ff-only integration pull, delete task branches (no TASK md edits) |
 | `vibeops task release` | Release PR: integration → production (GitFlow) |
 | `vibeops pull` | Fetch remote + update integration branch (e.g. develop) |
-| `vibeops status` | Now / Next briefing: focus TASK, Git, what to run next |
+| `vibeops status` | **Now / Next** card — focus TASK, checklist, what to run next |
 | `vibeops llm` | Connect LLM providers (`connect` · `status` · `use`) |
 
+## Installation
+
+Node.js 20+.
+
+```bash
+npm install -g @goodtek/vibeops@2.5.1
+# or latest: npm install -g @goodtek/vibeops
+vibeops --version   # expect 2.5.1
+```
+
+If `vibeops --version` stays on an old release after install, check for a **shell alias** or **Volta** shim shadowing npm:
+
+```bash
+type -a vibeops
+# alias → unalias vibeops (and remove from ~/.zshrc)
+# ~/.volta/bin/vibeops → volta install @goodtek/vibeops@2.5.1
+```
+
+**Upgrading from before 2.5:** `task reship` was removed. Use `vibeops task ship` (re-run while the PR is open; after merge use confirm or `--new-cycle`).
+
+Development:
+
+```bash
+pnpm install && pnpm build && pnpm smoke
+```
+
 ## Init
 
 Interactive init asks which agents to install, Git branch policy, then **where the remote lives** (GitHub / GitLab / skip) and whether to **create** or **connect** a repository. If `gh`/`glab` is missing, init prints install hints (optional `brew install` with consent) or accepts a URL — it does not block the rest of VibeOps.
@@ -83,27 +111,31 @@ vibeops task release
 
 Only one TASK **In Progress** at a time (`task add` blocks otherwise). **Shipped** slices do not block the next add; merge on the host or with `task merge`, then optional `task sync`.
 
-## LLM (optional)
+`task add` fast-forward-pulls the integration branch first. If that fails (diverged / **app** dirty / local-ahead), it prints the cause and fix commands and **does not** create a TASK file. VibeOps/governance-only changes (e.g. `.vibeops.json` after `init`) do **not** block. If a previous run left a TASK file without a branch, rerun `task add` to resume.
 
-For **`task add`** / **`task ship`** only (not for coding in the IDE). When `-m` is omitted, `ship` uses a connected provider to draft the commit subject:
+## Status
 
 ```bash
-vibeops llm connect
-vibeops llm use auto   # auto | codex-oauth | cursor-agent | openai
+vibeops status
 ```
 
-## Installation
+Prints a short card:
 
-Node.js 20+.
+- **NOW** — focus TASK, stage, Result/Test checklist, branch, PR
+- **NEXT** — one primary action (copy-pasteable command)
+- footer — project, task counts, LLM (dim)
 
 ```bash
-npm install -g @goodtek/vibeops
+vibeops status --json   # machine-readable
 ```
 
-Development:
+## LLM (optional)
+
+For **`task add`** / **`task ship`** only (not for coding in the IDE). When `-m` is omitted, `ship` uses a connected provider to draft the commit subject:
 
 ```bash
-pnpm install && pnpm build && pnpm smoke
+vibeops llm connect
+vibeops llm use auto   # auto | codex-oauth | cursor-agent | openai
 ```
 
 ## Flags (common)

package/dist/commands/pull.js

@@ -1,5 +1,6 @@
 import { resolve } from "node:path";
 import { GitConfigError, requireGitConfig } from "../lib/git-config.js";
+import { diagnoseIntegrationSync, printIntegrationSyncDiagnosis, } from "../lib/git-integration-sync.js";
 import { gitFetchRemote, gitPullFastForwardOnly, gitRemoteBranchExists, gitRemoteUrl, gitSwitchToBranch, readGitInfo, } from "../lib/git.js";
 import { bold, cyan, dim, log } from "../lib/logger.js";
 /**
@@ -73,7 +74,13 @@ export async function pullCommand(options = {}) {
     }
     catch (e) {
         const msg = e instanceof Error ? e.message : String(e);
-        log.error(`Could not fast-forward ${integrationBranch}: ${msg}. Commit or stash local changes, then rerun \`vibeops pull\`.`);
+        const diagnosis = await diagnoseIntegrationSync(cwd, remote, integrationBranch);
+        if (!diagnosis.ok) {
+            printIntegrationSyncDiagnosis(diagnosis);
+        }
+        else {
+            log.error(`Could not fast-forward ${integrationBranch}: ${msg}. Commit or stash local changes, then rerun \`vibeops pull\`.`);
+        }
         process.exitCode = 1;
     }
 }

package/dist/commands/task-add.js

@@ -1,6 +1,7 @@
 import { resolve } from "node:path";
 import { pathExists, writeText } from "../lib/filesystem.js";
 import { GitConfigError, requireGitConfig } from "../lib/git-config.js";
+import { ensureIntegrationSynced, printIntegrationSyncDiagnosis, } from "../lib/git-integration-sync.js";
 import { askInput } from "../lib/inquirer-helpers.js";
 import { bold, cyan, dim, log, yellow } from "../lib/logger.js";
 import { projectPaths } from "../lib/paths.js";
@@ -8,7 +9,7 @@ import { slugify } from "../lib/slug.js";
 import { fallbackTaskDraft, llmScaffoldTask } from "../lib/task-add-llm.js";
 import { allocateNextTaskNumber, formatTaskId, uniqueTaskPath, } from "../lib/task-scaffold.js";
 import { findBlockingTask, relPath } from "../lib/task-context.js";
-import { startTaskBranch } from "../lib/task-start.js";
+import { isIncompleteTaskStart, startTaskBranch } from "../lib/task-start.js";
 import { loadActionableTasks, readGitContext } from "../lib/task.js";
 async function loadGitConfigOrNull(root, dryRun) {
     try {
@@ -25,6 +26,31 @@ async function loadGitConfigOrNull(root, dryRun) {
         throw e;
     }
 }
+async function finishWithBranch(root, taskId, filePath, gitCfg, opts) {
+    const relFile = relPath(root, filePath);
+    log.blank();
+    log.step("Starting task branch…");
+    const started = await startTaskBranch({
+        cwd: root,
+        taskFile: filePath,
+        integrationBranch: gitCfg.integrationBranch,
+        remote: gitCfg.remote,
+        allowDirty: true,
+        dryRun: opts.dryRun,
+        skipIntegrationPull: opts.skipIntegrationPull,
+    });
+    if (!started) {
+        process.exitCode = 1;
+        return;
+    }
+    if (opts.dryRun)
+        return;
+    log.blank();
+    log.info(bold("Next in Cursor"));
+    log.info(`  Ask:  @${relFile} — plan Scope / Acceptance Criteria`);
+    log.info(`  Agent: same file — implement`);
+    log.info(`  Ship: ${cyan(`vibeops task ship ${taskId}`)}`);
+}
 export async function taskAddCommand(opts = {}) {
     const root = resolve(opts.cwd ?? process.cwd());
     const dryRun = opts.dryRun === true;
@@ -36,7 +62,34 @@ export async function taskAddCommand(opts = {}) {
         return;
     const paths = projectPaths(root);
     const blocking = await findBlockingTask(paths, root);
-    if (blocking !== null) {
+    // Resume: In Progress file exists but task branch / Git Context was never finished.
+    if (blocking !== null && gitCfg !== null) {
+        const incomplete = await isIncompleteTaskStart(root, blocking.filePath);
+        if (incomplete) {
+            log.warn(`${yellow("Incomplete")} — ${bold(blocking.id)} exists but the task branch was not created.`);
+            log.info(`  ${dim("file")}   ${relPath(root, blocking.filePath)}`);
+            log.info(dim("Resuming branch setup (will not create a new TASK)…"));
+            if (!dryRun) {
+                const synced = await ensureIntegrationSynced({
+                    cwd: root,
+                    remote: gitCfg.remote,
+                    integrationBranch: gitCfg.integrationBranch,
+                    fetch: true,
+                });
+                if (!synced.ok) {
+                    printIntegrationSyncDiagnosis(synced.diagnosis);
+                    process.exitCode = 1;
+                    return;
+                }
+                if (synced.pulled)
+                    log.info(dim(synced.diagnosis.summary));
+            }
+            await finishWithBranch(root, blocking.id, blocking.filePath, gitCfg, {
+                dryRun,
+                skipIntegrationPull: true,
+            });
+            return;
+        }
         const ctx = await readGitContext(blocking.filePath);
         log.warn(`${yellow("Blocked")} — ${bold(blocking.id)} is still open (${blocking.title || "no title"}).`);
         if (ctx) {
@@ -49,6 +102,34 @@ export async function taskAddCommand(opts = {}) {
         process.exitCode = 1;
         return;
     }
+    // Preflight: sync integration BEFORE writing a new TASK file (avoids half-created TASKs).
+    if (!dryRun && gitCfg !== null) {
+        log.step("Checking integration branch…");
+        const synced = await ensureIntegrationSynced({
+            cwd: root,
+            remote: gitCfg.remote,
+            integrationBranch: gitCfg.integrationBranch,
+            fetch: true,
+        });
+        if (!synced.ok) {
+            printIntegrationSyncDiagnosis(synced.diagnosis);
+            log.blank();
+            log.info(dim("No TASK file was created. Fix the integration branch, then rerun task add."));
+            process.exitCode = 1;
+            return;
+        }
+        if (synced.pulled) {
+            log.ok(synced.diagnosis.summary);
+        }
+        else if (synced.diagnosis.kind === "no_remote_branch" ||
+            synced.diagnosis.kind === "no_remote") {
+            log.info(dim(synced.diagnosis.summary));
+        }
+        else {
+            log.info(dim(`Integration ${gitCfg.integrationBranch} is ready.`));
+        }
+        log.blank();
+    }
     const ideaDefault = "New work slice";
     const idea = await askInput({
         message: "What are you doing now? (short)",
@@ -106,22 +187,8 @@ export async function taskAddCommand(opts = {}) {
     }
     await writeText(filePath, markdown);
     log.ok(`Created ${bold(taskId)} → ${cyan(relFile)}`);
-    log.blank();
-    log.step("Starting task branch…");
-    const started = await startTaskBranch({
-        cwd: root,
-        taskFile: filePath,
-        integrationBranch: gitCfg.integrationBranch,
-        remote: gitCfg.remote,
-        allowDirty: true,
+    await finishWithBranch(root, taskId, filePath, gitCfg, {
+        dryRun: false,
+        skipIntegrationPull: true,
     });
-    if (!started) {
-        process.exitCode = 1;
-        return;
-    }
-    log.blank();
-    log.info(bold("Next in Cursor"));
-    log.info(`  Ask:  @${relFile} — plan Scope / Acceptance Criteria`);
-    log.info(`  Agent: same file — implement`);
-    log.info(`  Ship: ${cyan(`vibeops task ship ${taskId}`)}`);
 }

package/dist/lib/git-integration-sync.js

@@ -0,0 +1,232 @@
+import { gitFetchRemote, gitGovernanceOnlyDirty, gitLeftRightCount, gitPullFastForwardOnly, gitRemoteBranchExists, gitRemoteUrl, gitRevParse, gitSwitchToBranch, readGitInfo, restoreGovernanceStashAfterSwitch, stashGovernanceIfBlocking, } from "./git.js";
+import { cyan, dim, log } from "./logger.js";
+function remoteRef(remote, branch) {
+    return `${remote}/${branch}`;
+}
+/**
+ * Classify why `git pull --ff-only` would fail for the integration branch.
+ * Call after fetch when possible so `origin/branch` is current.
+ *
+ * Governance-only dirt (`.vibeops.json`, docs/, `.vibeops/`, …) does **not**
+ * block — `task add` right after `init` must work.
+ */
+export async function diagnoseIntegrationSync(cwd, remote, integrationBranch) {
+    if ((await gitRemoteUrl(cwd, remote)) === null) {
+        return {
+            ok: true,
+            kind: "no_remote",
+            summary: `No git remote "${remote}" — using local ${integrationBranch} only.`,
+            fixes: [],
+        };
+    }
+    if (!(await gitRemoteBranchExists(cwd, remote, integrationBranch))) {
+        return {
+            ok: true,
+            kind: "no_remote_branch",
+            summary: `No ${remote}/${integrationBranch} yet — local branch is fine for first push.`,
+            fixes: [],
+        };
+    }
+    const git = await readGitInfo(cwd);
+    if (git.dirty === true) {
+        const gov = await gitGovernanceOnlyDirty(cwd);
+        if (!gov.onlyGovernance) {
+            const blocking = gov.nonGovernancePaths.slice(0, 8);
+            const more = gov.nonGovernancePaths.length > blocking.length
+                ? ` (+${gov.nonGovernancePaths.length - blocking.length} more)`
+                : "";
+            return {
+                ok: false,
+                kind: "dirty",
+                summary: `Working tree has app changes — cannot fast-forward ${integrationBranch}.`,
+                fixes: [
+                    "git status",
+                    `# Blocking (non-governance): ${blocking.join(", ")}${more}`,
+                    "git stash push -u -m \"vibeops: before sync\"",
+                    `git checkout ${integrationBranch}`,
+                    `git pull --ff-only ${remote} ${integrationBranch}`,
+                    "git stash pop   # if you stashed",
+                    "vibeops task add",
+                ],
+            };
+        }
+        // Governance-only dirty (.vibeops.json after init, docs, …) — proceed.
+    }
+    const localSha = await gitRevParse(cwd, integrationBranch);
+    const remoteSha = await gitRevParse(cwd, remoteRef(remote, integrationBranch));
+    if (localSha === null || remoteSha === null) {
+        return {
+            ok: false,
+            kind: "pull_failed",
+            summary: `Could not resolve ${integrationBranch} or ${remote}/${integrationBranch}.`,
+            fixes: [
+                `git fetch ${remote}`,
+                `git checkout ${integrationBranch}`,
+                `git pull --ff-only ${remote} ${integrationBranch}`,
+            ],
+        };
+    }
+    if (localSha === remoteSha) {
+        return {
+            ok: true,
+            kind: "ok",
+            summary: `${integrationBranch} matches ${remote}/${integrationBranch}.`,
+            fixes: [],
+        };
+    }
+    const counts = await gitLeftRightCount(cwd, integrationBranch, remoteRef(remote, integrationBranch));
+    const ahead = counts?.left ?? 0;
+    const behind = counts?.right ?? 0;
+    if (ahead > 0 && behind > 0) {
+        return {
+            ok: false,
+            kind: "diverged",
+            summary: `Local ${integrationBranch} and ${remote}/${integrationBranch} have diverged (local +${ahead}, remote +${behind}).`,
+            fixes: [
+                `git fetch ${remote}`,
+                `git checkout ${integrationBranch}`,
+                `# Prefer remote (discards local-only commits on ${integrationBranch}):`,
+                `git reset --hard ${remote}/${integrationBranch}`,
+                `# Or keep local commits: git pull --rebase ${remote} ${integrationBranch}`,
+                "vibeops task add",
+            ],
+            ahead,
+            behind,
+        };
+    }
+    if (ahead > 0 && behind === 0) {
+        return {
+            ok: false,
+            kind: "ahead",
+            summary: `Local ${integrationBranch} is ${ahead} commit(s) ahead of ${remote}/${integrationBranch} — fast-forward pull cannot apply.`,
+            fixes: [
+                `git checkout ${integrationBranch}`,
+                `# Push local commits, or reset to remote if they should not exist:`,
+                `git push -u ${remote} ${integrationBranch}`,
+                `# or: git reset --hard ${remote}/${integrationBranch}`,
+                "vibeops task add",
+            ],
+            ahead,
+            behind,
+        };
+    }
+    // behind only — ff-only should work
+    return {
+        ok: true,
+        kind: "ok",
+        summary: `${integrationBranch} is ${behind} commit(s) behind ${remote}/${integrationBranch} (ff-only OK).`,
+        fixes: [],
+        ahead,
+        behind,
+    };
+}
+export function printIntegrationSyncDiagnosis(d) {
+    if (d.ok) {
+        if (d.kind !== "ok" && d.kind !== "no_remote_branch")
+            log.info(dim(d.summary));
+        return;
+    }
+    log.error(d.summary);
+    if (d.fixes.length > 0) {
+        log.blank();
+        log.info(dim("Fix (run in this repo):"));
+        for (const line of d.fixes) {
+            if (line.startsWith("#"))
+                log.info(dim(`  ${line}`));
+            else
+                log.info(`  ${cyan(line)}`);
+        }
+    }
+}
+/**
+ * Fetch + ensure local integration can be used as the base for a new task branch.
+ * Switches to the integration branch, then `--ff-only` pull when needed. Never force-resets.
+ * Governance-only dirt is stashed around switch/pull so post-`init` `.vibeops.json` edits do not block.
+ */
+export async function ensureIntegrationSynced(opts) {
+    const { cwd, remote, integrationBranch } = opts;
+    const doFetch = opts.fetch !== false;
+    if (opts.dryRun === true) {
+        const d = await diagnoseIntegrationSync(cwd, remote, integrationBranch);
+        return { ok: d.ok || d.kind === "no_remote_branch", diagnosis: d, pulled: false };
+    }
+    if ((await gitRemoteUrl(cwd, remote)) === null) {
+        const d = await diagnoseIntegrationSync(cwd, remote, integrationBranch);
+        return { ok: true, diagnosis: d, pulled: false };
+    }
+    if (doFetch) {
+        try {
+            await gitFetchRemote(cwd, remote);
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            log.warn(dim(`git fetch failed (${msg}) — diagnosing with local refs.`));
+        }
+    }
+    const git = await readGitInfo(cwd);
+    if (git.branch !== integrationBranch) {
+        const switched = await gitSwitchToBranch(cwd, integrationBranch, remote);
+        if (!switched) {
+            return {
+                ok: false,
+                diagnosis: {
+                    ok: false,
+                    kind: "pull_failed",
+                    summary: `Could not switch to integration branch "${integrationBranch}".`,
+                    fixes: [
+                        "git status",
+                        `git checkout ${integrationBranch}`,
+                        `# If checkout fails due to local changes: git stash -u`,
+                        `git pull --ff-only ${remote} ${integrationBranch}`,
+                        "vibeops task add",
+                    ],
+                },
+                pulled: false,
+            };
+        }
+    }
+    let diagnosis = await diagnoseIntegrationSync(cwd, remote, integrationBranch);
+    if (!diagnosis.ok) {
+        return { ok: false, diagnosis, pulled: false };
+    }
+    if (diagnosis.kind === "no_remote_branch") {
+        return { ok: true, diagnosis, pulled: false };
+    }
+    const localSha = await gitRevParse(cwd, integrationBranch);
+    const remoteSha = await gitRevParse(cwd, remoteRef(remote, integrationBranch));
+    if (localSha !== null && remoteSha !== null && localSha === remoteSha) {
+        return { ok: true, diagnosis, pulled: false };
+    }
+    // Stash governance dirt so ff-only pull cannot be blocked by `.vibeops.json` etc.
+    const stashed = await stashGovernanceIfBlocking(cwd);
+    try {
+        await gitPullFastForwardOnly(cwd, remote, integrationBranch);
+        diagnosis = {
+            ok: true,
+            kind: "ok",
+            summary: `Pulled latest ${remote}/${integrationBranch} (--ff-only).`,
+            fixes: [],
+        };
+        return { ok: true, diagnosis, pulled: true };
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        diagnosis = await diagnoseIntegrationSync(cwd, remote, integrationBranch);
+        if (diagnosis.ok) {
+            diagnosis = {
+                ok: false,
+                kind: "pull_failed",
+                summary: `git pull --ff-only failed: ${msg}`,
+                fixes: [
+                    `git checkout ${integrationBranch}`,
+                    `git pull --ff-only ${remote} ${integrationBranch}`,
+                    "vibeops task add",
+                ],
+            };
+        }
+        return { ok: false, diagnosis, pulled: false };
+    }
+    finally {
+        await restoreGovernanceStashAfterSwitch(cwd, stashed);
+    }
+}

package/dist/lib/git.js

@@ -299,12 +299,17 @@ const GOVERNANCE_DOC_REL_PREFIXES = [
     "docs/project/",
     "docs/logs/",
     ".vibeops/",
+    ".cursor/rules/",
 ];
+/** Root files owned by vibeops init / config (not under `.vibeops/`). */
+const GOVERNANCE_DOC_EXACT = new Set([".vibeops.json", "AGENTS.md"]);
 function normalizeRepoRelPath(p) {
     return p.replace(/\\/g, "/").replace(/^\/+/, "");
 }
 export function isGovernanceDocumentationPath(repoRelativePath) {
     const n = normalizeRepoRelPath(repoRelativePath);
+    if (GOVERNANCE_DOC_EXACT.has(n))
+        return true;
     for (const prefix of GOVERNANCE_DOC_REL_PREFIXES) {
         if (n.startsWith(prefix))
             return true;
@@ -519,6 +524,31 @@ export async function gitDeleteRemoteBranch(cwd, remote, branch) {
 export async function gitPullFastForwardOnly(cwd, remote, branch) {
     await runGit(cwd, ["pull", "--ff-only", remote, branch]);
 }
+/**
+ * Commits reachable only from `left` vs only from `right` (git left-right).
+ * Example: `develop...origin/develop` → { left: local-only, right: remote-only }.
+ */
+export async function gitLeftRightCount(cwd, leftRef, rightRef) {
+    try {
+        const { stdout } = await runGit(cwd, [
+            "rev-list",
+            "--left-right",
+            "--count",
+            `${leftRef}...${rightRef}`,
+        ]);
+        const parts = stdout.trim().split(/\s+/);
+        if (parts.length < 2)
+            return null;
+        const left = Number.parseInt(parts[0], 10);
+        const right = Number.parseInt(parts[1], 10);
+        if (!Number.isFinite(left) || !Number.isFinite(right))
+            return null;
+        return { left, right };
+    }
+    catch {
+        return null;
+    }
+}
 /** Merge `remote/branch` into the current HEAD (follow-up integration). */
 export async function gitMergeRemoteBranch(cwd, remote, branch) {
     await runGit(cwd, ["merge", `${remote}/${branch}`, "--no-edit"]);

package/dist/lib/task-start.js

@@ -1,11 +1,19 @@
 import { relative, resolve } from "node:path";
 import { branchNameForTaskFile, readGitContext, readTaskFile, updateInlineStatus, upsertGitContext, } from "./task.js";
-import { gitBranchExists, gitCheckout, gitCheckoutNewBranch, gitGovernanceOnlyDirty, gitHeadCommit, gitPullFastForwardOnly, gitRemoteBranchExists, gitSwitchToBranch, gitRemoteUrl, readGitInfo, } from "./git.js";
+import { gitBranchExists, gitCheckout, gitCheckoutNewBranch, gitGovernanceOnlyDirty, gitHeadCommit, gitSwitchToBranch, readGitInfo, } from "./git.js";
+import { ensureIntegrationSynced, printIntegrationSyncDiagnosis, } from "./git-integration-sync.js";
 import { cyan, dim, log } from "./logger.js";
 function relOrAbs(root, p) {
     const r = relative(root, p);
     return r === "" ? "." : r.startsWith("..") ? p : r;
 }
+/** True when In Progress TASK has no task branch yet (failed mid-add). */
+export async function isIncompleteTaskStart(cwd, taskFile) {
+    const ctx = await readGitContext(taskFile);
+    if (ctx === null)
+        return true;
+    return !(await gitBranchExists(cwd, ctx.taskBranch));
+}
 /** Create or resume task branch from integration branch and mark TASK In Progress. */
 export async function startTaskBranch(opts) {
     const cwd = resolve(opts.cwd);
@@ -49,20 +57,21 @@ export async function startTaskBranch(opts) {
         }
     }
     // Ensure integration branch is up-to-date before creating a new task branch.
-    if (!branchExists) {
-        const remoteUrl = await gitRemoteUrl(cwd, remote);
-        if (remoteUrl) {
-            const hasRemoteBranch = await gitRemoteBranchExists(cwd, remote, integrationBranch);
-            if (hasRemoteBranch) {
-                try {
-                    await gitPullFastForwardOnly(cwd, remote, integrationBranch);
-                    log.info(dim(`Pulled latest ${remote}/${integrationBranch} (--ff-only).`));
-                }
-                catch {
-                    log.warn(`Could not fast-forward pull ${remote}/${integrationBranch}. Resolve manually, then rerun task add.`);
-                    return false;
-                }
-            }
+    if (!branchExists && opts.skipIntegrationPull !== true) {
+        const synced = await ensureIntegrationSynced({
+            cwd,
+            remote,
+            integrationBranch,
+            fetch: true,
+        });
+        if (!synced.ok) {
+            printIntegrationSyncDiagnosis(synced.diagnosis);
+            log.blank();
+            log.info(dim(`TASK file is already created — after fixing sync, rerun ${cyan("vibeops task add")} to resume the branch (does not create a second TASK).`));
+            return false;
+        }
+        if (synced.pulled) {
+            log.info(dim(synced.diagnosis.summary));
         }
     }
     const baseBranch = integrationBranch;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodtek/vibeops",
-  "version": "2.5.0",
+  "version": "2.5.2",
   "description": "Minimal CLI rails for Cursor-based TASK-driven vibe coding.",
   "type": "module",
   "packageManager": "pnpm@9.15.9",
@@ -39,7 +39,9 @@
     "smoke": "pnpm typecheck && pnpm build && node --test \"tests/*.test.mjs\" && node scripts/smoke.mjs",
     "clean": "rm -rf dist",
     "prepack": "pnpm clean && pnpm build",
-    "publish:dry": "pnpm publish --dry-run --no-git-checks"
+    "publish:dry": "pnpm publish --dry-run --no-git-checks",
+    "publish:npm": "scripts/npm-publish.sh",
+    "publish:npm:dry": "scripts/npm-publish.sh --dry-run"
   },
   "keywords": [
     "cursor",