@goodtek/vibeops 2.2.0 → 2.3.0

package/CHANGELOG.md

@@ -4,6 +4,23 @@ All notable changes to VibeOps are documented here.
 
 ## Unreleased
 
+## 2.3.0 - 2026-06-09
+
+### Added
+
+- **`vibeops task del [TASK-NNN]`** — cancel a TASK before merge: delete `docs/tasks/*.md`, close open MR/PR (unless `--no-close-mr`), delete local/remote `task/*` branch. Refuses when the MR is **merged** into integration.
+
+### Flags
+
+- `--dry-run`, `--force` (dirty working tree), `--no-remote-delete`, `--no-close-mr`, `--cwd`
+
+## 2.2.1 - 2026-06-09
+
+### Fixed
+
+- **`vibeops task reship --allow-open-mr`**: push then reuse the open MR/PR instead of failing on duplicate `gh pr create`. Skips reship metadata archive when updating the same PR.
+- **`finishTaskWithPullRequest`**: push before checking for an open MR so follow-up commits reach the remote.
+
 ## 2.2.0 - 2026-06-09
 
 ### Added

package/README.md

@@ -13,6 +13,7 @@ VibeOps bootstraps an **agent-friendly repo**, starts numbered **TASK** files on
 |---------|---------|
 | `vibeops init` | Core docs + agent packs (cursor / claude / codex) |
 | `vibeops task add` | New `TASK-NNN` file + task branch |
+| `vibeops task del` | Cancel TASK before merge (md + branch + close open MR) |
 | `vibeops task ship` | LLM summary, commit, push, open MR/PR (Status → **Shipped**) |
 | `vibeops task reship` | Shipped follow-up: move uncommitted work to task branch, commit, new MR/PR (Status stays Shipped) |
 | `vibeops task merge` | Merge TASK MR/PR into integration branch (default: squash) |
@@ -97,6 +98,7 @@ pnpm install && pnpm build && pnpm smoke
 
 - **`init`**: `--clients`, `--yes`, `--dry-run`, `--force`, `--git`, `--initial-commit`, `--git-policy gitflow|trunk`, `--integration-branch`, `--production-branch`, `--allow-no-remote`, `--cwd`
 - **`task add`**: `--dry-run`, `--non-interactive --idea "…"`
+- **`task del`**: `--dry-run`, `--force`, `--no-remote-delete`, `--no-close-mr`
 - **`task ship`**: `--dry-run`, `--no-pr`
 - **`task reship`**: `--dry-run`, `--no-pr`, `--no-integrate`, `--recreate-branch`, `--skip-llm`, `--allow-open-mr`
 - **`task merge`**: `--dry-run`, `--merge`, `--rebase`

package/dist/cli.js

@@ -5,6 +5,7 @@ import { initCommand } from "./commands/init.js";
 import { llmConnectCommand, llmStatusCommand, llmUseCommand } from "./commands/llm.js";
 import { statusCommand } from "./commands/status.js";
 import { taskAddCommand } from "./commands/task-add.js";
+import { taskDelCommand } from "./commands/task-del.js";
 import { taskMergeCommand } from "./commands/task-merge.js";
 import { taskReleaseCommand } from "./commands/task-release.js";
 import { taskShipCommand } from "./commands/task-ship.js";
@@ -58,7 +59,9 @@ program
         gitHost: opts.gitHost,
     });
 });
-const task = program.command("task").description("TASK lifecycle (add · ship · reship · merge · sync · release)");
+const task = program
+    .command("task")
+    .description("TASK lifecycle (add · del · ship · reship · merge · sync · release)");
 task
     .command("add")
     .description("Create next TASK-NNN, task branch, In Progress")
@@ -74,6 +77,23 @@ task
         cwd: opts.cwd,
     });
 });
+task
+    .command("del [taskRef]")
+    .description("Delete TASK before merge: remove md, close open MR/PR, delete task branch")
+    .option("--dry-run", "Plan only")
+    .option("--force", "Proceed with a dirty working tree (changes may remain)")
+    .option("--no-remote-delete", "Keep the task branch on the remote")
+    .option("--no-close-mr", "Do not close an open MR/PR")
+    .option("--cwd <path>", "Target directory")
+    .action(async (taskRef, opts) => {
+    await taskDelCommand(taskRef, {
+        dryRun: Boolean(opts.dryRun),
+        force: Boolean(opts.force),
+        noRemoteDelete: Boolean(opts.noRemoteDelete),
+        noCloseMr: Boolean(opts.noCloseMr),
+        cwd: opts.cwd,
+    });
+});
 task
     .command("ship [taskRef]")
     .description("Submit TASK: LLM summary, commit, push, open MR/PR (Status → Shipped)")
@@ -95,7 +115,7 @@ task
     .option("--no-integrate", "Skip merging integration branch into task branch")
     .option("--recreate-branch", "Create task branch from integration instead of reusing local/remote ref")
     .option("--skip-llm", "Do not run LLM for Result / Test Result")
-    .option("--allow-open-mr", "Allow reship while the recorded MR is still open")
+    .option("--allow-open-mr", "Update the open MR/PR with new commits (merge before reship for a new PR)")
     .option("--cwd <path>", "Target directory")
     .action(async (taskRef, opts) => {
     await taskReshipCommand(taskRef, {

package/dist/commands/task-del.js

@@ -0,0 +1,104 @@
+import { resolve } from "node:path";
+import { bold, cyan, dim, log } from "../lib/logger.js";
+import { projectPaths } from "../lib/paths.js";
+import { relPath } from "../lib/task-context.js";
+import { assertTaskDeletable, assertWorkingTreeForDel, closeOpenTaskMergeRequestIfNeeded, deleteTaskBranches, deleteTaskMarkdown, loadGitConfigForDel, resolveDelTarget, taskDelNotFoundMessage, validateTaskBranchForDel, } from "../lib/task-del.js";
+import { readGitContext, statusDisplay } from "../lib/task.js";
+export async function taskDelCommand(taskRef, options = {}) {
+    const cwd = resolve(options.cwd ?? process.cwd());
+    const dryRun = options.dryRun === true;
+    const paths = projectPaths(cwd);
+    const target = await resolveDelTarget(paths, cwd, taskRef);
+    if (target === null) {
+        log.error(taskDelNotFoundMessage(taskRef));
+        process.exitCode = 1;
+        return;
+    }
+    const { taskId, taskFile, meta, taskBranch } = target;
+    const relFile = relPath(cwd, taskFile);
+    log.info(bold(`vibeops task del ${taskId}`));
+    log.info(`  ${dim("file")}    ${relFile}`);
+    log.info(`  ${dim("branch")}  ${taskBranch}`);
+    log.info(`  ${dim("status")}  ${statusDisplay(meta.status)}`);
+    log.blank();
+    const deletable = await assertTaskDeletable(cwd, target);
+    if (!deletable.ok) {
+        log.error(deletable.reason);
+        process.exitCode = 1;
+        return;
+    }
+    const gitCfg = dryRun
+        ? await loadGitConfigForDel(cwd).catch(() => null)
+        : await loadGitConfigForDel(cwd);
+    if (!dryRun && gitCfg === null) {
+        process.exitCode = 1;
+        return;
+    }
+    const integrationBranch = gitCfg?.integrationBranch ?? "develop";
+    const productionBranch = gitCfg?.productionBranch ?? "main";
+    const remote = gitCfg?.remote ?? "origin";
+    if (!validateTaskBranchForDel(taskBranch, integrationBranch, productionBranch)) {
+        process.exitCode = 1;
+        return;
+    }
+    if (dryRun) {
+        log.info(bold("dry-run — would:"));
+        const ctx = await readGitContext(taskFile);
+        if (ctx !== null) {
+            await closeOpenTaskMergeRequestIfNeeded({
+                cwd,
+                taskFile,
+                taskBranch,
+                baseBranch: ctx.baseBranch,
+                dryRun: true,
+                skipClose: options.noCloseMr === true,
+            });
+        }
+        log.info(`  · git switch ${integrationBranch} (if on ${taskBranch})`);
+        await deleteTaskBranches({
+            cwd,
+            taskBranch,
+            integrationBranch,
+            remote,
+            dryRun: true,
+            noRemoteDelete: options.noRemoteDelete === true,
+        });
+        await deleteTaskMarkdown(taskFile, true);
+        log.blank();
+        log.info(`Next: ${cyan("vibeops task add")}`);
+        return;
+    }
+    if (!(await assertWorkingTreeForDel(cwd, options.force === true))) {
+        process.exitCode = 1;
+        return;
+    }
+    const ctx = await readGitContext(taskFile);
+    if (ctx === null) {
+        log.error("Git Context missing.");
+        process.exitCode = 1;
+        return;
+    }
+    await closeOpenTaskMergeRequestIfNeeded({
+        cwd,
+        taskFile,
+        taskBranch,
+        baseBranch: ctx.baseBranch,
+        dryRun: false,
+        skipClose: options.noCloseMr === true,
+    });
+    const branchesOk = await deleteTaskBranches({
+        cwd,
+        taskBranch,
+        integrationBranch,
+        remote,
+        dryRun: false,
+        noRemoteDelete: options.noRemoteDelete === true,
+    });
+    if (!branchesOk) {
+        process.exitCode = 1;
+        return;
+    }
+    await deleteTaskMarkdown(taskFile, false);
+    log.blank();
+    log.info(`Next: ${cyan("vibeops task add")}`);
+}

package/dist/commands/task-reship.js

@@ -44,7 +44,8 @@ export async function taskReshipCommand(taskRef, options = {}) {
     }
     const integrationBranch = gitCfg?.integrationBranch ?? "develop";
     const remote = gitCfg?.remote ?? "origin";
-    if (!dryRun && !(await assertMergeRequestNotOpen(cwd, taskFile, options.allowOpenMr === true))) {
+    const updateOpenMr = options.allowOpenMr === true;
+    if (!dryRun && !(await assertMergeRequestNotOpen(cwd, taskFile, updateOpenMr))) {
         process.exitCode = 1;
         return;
     }
@@ -113,7 +114,12 @@ export async function taskReshipCommand(taskRef, options = {}) {
     log.blank();
     if (dryRun) {
         log.info(bold("dry-run — would also:"));
-        log.info("  · feat commit + reship metadata, then push once and open MR/PR (unless --no-pr)");
+        if (updateOpenMr) {
+            log.info("  · feat commit, push, update open MR/PR (unless --no-pr)");
+        }
+        else {
+            log.info("  · feat commit + reship metadata, then push once and open MR/PR (unless --no-pr)");
+        }
         log.blank();
         log.info(`Next: ${cyan("vibeops task merge")}, then optional ${cyan("task sync")}`);
         return;
@@ -137,19 +143,24 @@ export async function taskReshipCommand(taskRef, options = {}) {
         process.exitCode = 1;
         return;
     }
-    gitCtx = await refreshGitContextBaseCommit(taskFile, gitCtx, cwd);
-    gitCtx = await prepareGitContextForReship(cwd, taskFile, gitCtx);
-    await commitReshipMetadata({
-        cwd,
-        taskFile,
-        taskId: parts.id,
-        dryRun: false,
-    });
+    if (updateOpenMr) {
+        log.info(dim("Updating open MR/PR (--allow-open-mr)."));
+    }
+    else {
+        gitCtx = await refreshGitContextBaseCommit(taskFile, gitCtx, cwd);
+        gitCtx = await prepareGitContextForReship(cwd, taskFile, gitCtx);
+        await commitReshipMetadata({
+            cwd,
+            taskFile,
+            taskId: parts.id,
+            dryRun: false,
+        });
+    }
     const prResult = await finishTaskWithPullRequest({
         cwd,
         taskFile,
         skipPr: options.noPr === true,
-        forceNewMergeRequest: true,
+        forceNewMergeRequest: !updateOpenMr,
     });
     if (!prResult.ok) {
         log.error("Reship failed — fix push/MR, then rerun task reship.");

package/dist/lib/filesystem.js

@@ -1,4 +1,4 @@
-import { mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
+import { mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
 import { dirname, relative } from "node:path";
 export async function pathExists(path) {
     try {
@@ -45,6 +45,9 @@ export async function writeText(path, contents) {
     await ensureDir(dirname(path));
     await writeFile(path, contents, "utf-8");
 }
+export async function deleteFile(path) {
+    await rm(path, { force: true });
+}
 export async function walk(root) {
     const out = [];
     async function visit(dir) {

package/dist/lib/pr-create.js

@@ -197,6 +197,25 @@ export async function getMergeRequestState(cwd, host, url) {
         return "unknown";
     }
 }
+export async function closeMergeRequest(opts) {
+    const ref = prRefFromUrl(opts.url);
+    const label = mergeRequestLabel(opts.host);
+    if (opts.dryRun === true) {
+        log.info(`would close ${label} ${ref}`);
+        return;
+    }
+    if (opts.host === "gitlab") {
+        await execFileAsync("glab", ["mr", "close", ref], {
+            cwd: opts.cwd,
+            maxBuffer: 4 * 1024 * 1024,
+        });
+        return;
+    }
+    await execFileAsync("gh", ["pr", "close", ref], {
+        cwd: opts.cwd,
+        maxBuffer: 4 * 1024 * 1024,
+    });
+}
 export async function mergeMergeRequest(opts) {
     const ref = prRefFromUrl(opts.url);
     const method = opts.method ?? "squash";

package/dist/lib/task-del.js

@@ -0,0 +1,193 @@
+import { resolve } from "node:path";
+import { deleteFile } from "./filesystem.js";
+import { GitConfigError, requireGitConfig } from "./git-config.js";
+import { mergeRequestLabel } from "./git-host.js";
+import { gitBranchExists, gitDeleteBranch, gitDeleteRemoteBranch, gitGovernanceOnlyDirty, gitRemoteBranchExists, gitSwitchToBranch, readGitInfo, } from "./git.js";
+import { dim, log } from "./logger.js";
+import { closeMergeRequest, findMergeRequestByBranches, probeMergeRequestCli, } from "./pr-create.js";
+import { normalizeTaskRef } from "./resolve-task.js";
+import { getTaskMergeRequestLifecycle, resolveGitHostForCwd } from "./task-effective-status.js";
+import { findTaskFile, loadActionableTasks, pickInProgressTask, readGitContext, readTaskFile, } from "./task.js";
+export async function resolveDelTarget(paths, cwd, taskRef) {
+    const trimmed = taskRef?.trim();
+    let taskId;
+    let taskFile;
+    if (trimmed !== undefined && trimmed.length > 0) {
+        taskId = normalizeTaskRef(trimmed);
+        taskFile = await findTaskFile(paths.docsTasks, taskId);
+    }
+    else {
+        const inProgress = pickInProgressTask(await loadActionableTasks(paths.docsTasks));
+        if (inProgress === null) {
+            return null;
+        }
+        taskId = inProgress.id;
+        taskFile = inProgress.filePath;
+    }
+    if (taskFile === null) {
+        return null;
+    }
+    const meta = await readTaskFile(taskFile);
+    const ctx = await readGitContext(taskFile);
+    if (ctx === null) {
+        log.error(`No Git Context on ${taskId}. Cannot delete.`);
+        return null;
+    }
+    return { taskId, taskFile, meta, taskBranch: ctx.taskBranch };
+}
+export function taskDelNotFoundMessage(taskRef) {
+    if (taskRef?.trim()) {
+        return `TASK not found: ${normalizeTaskRef(taskRef)}. Check docs/tasks/.`;
+    }
+    return "No In Progress TASK found. Pass `vibeops task del TASK-NNN`.";
+}
+export async function assertTaskDeletable(cwd, target) {
+    const lifecycle = await getTaskMergeRequestLifecycle(cwd, target.taskFile);
+    if (lifecycle === "merged") {
+        return {
+            ok: false,
+            reason: `${target.taskId} is merged into integration — task del is not allowed. ` +
+                "Revert on develop if needed, or keep the TASK file as history.",
+        };
+    }
+    return { ok: true };
+}
+export async function assertWorkingTreeForDel(cwd, allowDirty) {
+    const git = await readGitInfo(cwd);
+    if (git.dirty !== true)
+        return true;
+    const gov = await gitGovernanceOnlyDirty(cwd);
+    if (gov.onlyGovernance)
+        return true;
+    if (allowDirty) {
+        log.warn("Uncommitted changes remain in the working tree after delete.");
+        return true;
+    }
+    log.error("Working tree is dirty. Commit, stash, restore, or rerun with --force to discard uncommitted work.");
+    return false;
+}
+function isProtectedBranch(name, integration, production) {
+    return name === integration || name === production || name === "main" || name === "master";
+}
+export async function deleteTaskBranches(opts) {
+    const cwd = resolve(opts.cwd);
+    if (opts.dryRun) {
+        if (await gitBranchExists(cwd, opts.taskBranch)) {
+            log.info(dim(`  would git branch -D ${opts.taskBranch}`));
+        }
+        if (opts.noRemoteDelete !== true &&
+            (await gitRemoteBranchExists(cwd, opts.remote, opts.taskBranch))) {
+            log.info(dim(`  would git push ${opts.remote} --delete ${opts.taskBranch}`));
+        }
+        return true;
+    }
+    const git = await readGitInfo(cwd);
+    if (git.branch === opts.taskBranch) {
+        const switched = await gitSwitchToBranch(cwd, opts.integrationBranch, opts.remote);
+        if (!switched) {
+            log.error(`Integration branch "${opts.integrationBranch}" not found.`);
+            return false;
+        }
+        log.ok(`On ${opts.integrationBranch}`);
+    }
+    if (await gitBranchExists(cwd, opts.taskBranch)) {
+        try {
+            await gitDeleteBranch(cwd, opts.taskBranch, { force: true });
+            log.ok(`Deleted local branch ${opts.taskBranch}`);
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            log.error(`Could not delete local ${opts.taskBranch}: ${msg}`);
+            return false;
+        }
+    }
+    else {
+        log.info(dim(`Local branch ${opts.taskBranch} not found — skipped.`));
+    }
+    if (opts.noRemoteDelete !== true &&
+        (await gitRemoteBranchExists(cwd, opts.remote, opts.taskBranch))) {
+        try {
+            await gitDeleteRemoteBranch(cwd, opts.remote, opts.taskBranch);
+            log.ok(`Deleted ${opts.remote}/${opts.taskBranch}`);
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            log.warn(`Could not delete remote ${opts.taskBranch}: ${msg}`);
+        }
+    }
+    else if (opts.noRemoteDelete === true) {
+        log.info(dim("Remote branch delete skipped (--no-remote-delete)."));
+    }
+    return true;
+}
+export async function closeOpenTaskMergeRequestIfNeeded(opts) {
+    if (opts.skipClose) {
+        log.info(dim("Open MR/PR close skipped (--no-close-mr)."));
+        return true;
+    }
+    const lifecycle = await getTaskMergeRequestLifecycle(opts.cwd, opts.taskFile);
+    if (lifecycle !== "open")
+        return true;
+    const host = await resolveGitHostForCwd(opts.cwd);
+    if (host === null) {
+        log.warn("Could not resolve Git host — close the MR/PR manually.");
+        return true;
+    }
+    const open = await findMergeRequestByBranches({
+        cwd: opts.cwd,
+        host,
+        headBranch: opts.taskBranch,
+        baseBranch: opts.baseBranch,
+        state: "open",
+    });
+    if (open === null)
+        return true;
+    const label = mergeRequestLabel(host);
+    if (!(await probeMergeRequestCli(host))) {
+        log.warn(`Open ${label}: ${open.url} — close it manually before deleting the branch.`);
+        return true;
+    }
+    try {
+        await closeMergeRequest({ cwd: opts.cwd, host, url: open.url, dryRun: opts.dryRun });
+        if (!opts.dryRun)
+            log.ok(`Closed ${label}`);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        log.warn(`Could not close ${label}: ${msg}`);
+        log.info(dim(`Close manually: ${open.url}`));
+    }
+    return true;
+}
+export async function deleteTaskMarkdown(taskFile, dryRun) {
+    if (dryRun) {
+        log.info(dim(`  would delete ${taskFile}`));
+        return;
+    }
+    await deleteFile(taskFile);
+    log.ok(`Deleted TASK file`);
+}
+export async function loadGitConfigForDel(cwd) {
+    try {
+        const cfg = await requireGitConfig(cwd);
+        return {
+            remote: cfg.remote,
+            integrationBranch: cfg.integrationBranch,
+            productionBranch: cfg.productionBranch,
+        };
+    }
+    catch (e) {
+        if (e instanceof GitConfigError) {
+            log.error(e.message);
+            return null;
+        }
+        throw e;
+    }
+}
+export function validateTaskBranchForDel(taskBranch, integrationBranch, productionBranch) {
+    if (isProtectedBranch(taskBranch, integrationBranch, productionBranch)) {
+        log.error(`Refusing to delete protected branch: ${taskBranch}`);
+        return false;
+    }
+    return true;
+}

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

@@ -7,6 +7,12 @@ import { dim, log } from "./logger.js";
 import { createMergeRequest, findMergeRequestByBranches, probeMergeRequestCli, } from "./pr-create.js";
 import { fallbackTaskPr, generateTaskPrWithLlm } from "./task-pr-llm.js";
 import { readGitContext, readTaskFile } from "./task.js";
+function mergeRequestAlreadyExistsMessage(msg) {
+    const lower = msg.toLowerCase();
+    return (lower.includes("already exists") ||
+        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`);
@@ -55,19 +61,6 @@ export async function finishTaskWithPullRequest(opts) {
     if (git.branch !== gitCtx.taskBranch) {
         log.warn(`Current branch is ${git.branch ?? "(detached)"}, not ${gitCtx.taskBranch}. Push may fail.`);
     }
-    if (opts.skipPr !== true && opts.forceNewMergeRequest !== true) {
-        const existing = await findMergeRequestByBranches({
-            cwd: opts.cwd,
-            host: gitCfg.host,
-            headBranch: gitCtx.taskBranch,
-            baseBranch: gitCtx.baseBranch,
-            state: "open",
-        });
-        if (existing !== null) {
-            log.info(dim(`Open ${label} already exists: ${existing.url}`));
-            return { ok: true, mergeRequestUrl: existing.url, pushed: true };
-        }
-    }
     const ahead = await gitCommitsAhead(opts.cwd, gitCtx.baseCommit, "HEAD");
     if (ahead === 0) {
         log.warn("No commits ahead of base — pushing branch anyway.");
@@ -85,6 +78,20 @@ export async function finishTaskWithPullRequest(opts) {
         log.info(dim("Merge request creation skipped (--no-pr)."));
         return { ok: true, pushed: true };
     }
+    if (opts.forceNewMergeRequest !== true) {
+        const existing = await findMergeRequestByBranches({
+            cwd: opts.cwd,
+            host: gitCfg.host,
+            headBranch: gitCtx.taskBranch,
+            baseBranch: gitCtx.baseBranch,
+            state: "open",
+        });
+        if (existing !== null) {
+            log.ok(`Open ${label} updated: ${existing.url}`);
+            log.info(dim("MR/PR URL is on the host — not written to TASK md (use task merge)."));
+            return { ok: true, mergeRequestUrl: existing.url, pushed: true };
+        }
+    }
     const cliOk = await probeMergeRequestCli(gitCfg.host);
     if (!cliOk) {
         const tool = gitCfg.host === "gitlab" ? "glab" : "gh";
@@ -121,6 +128,20 @@ export async function finishTaskWithPullRequest(opts) {
     }
     catch (e) {
         const msg = e instanceof Error ? e.message : String(e);
+        if (mergeRequestAlreadyExistsMessage(msg)) {
+            const existing = await findMergeRequestByBranches({
+                cwd: opts.cwd,
+                host: gitCfg.host,
+                headBranch: gitCtx.taskBranch,
+                baseBranch: gitCtx.baseBranch,
+                state: "open",
+            });
+            if (existing !== null) {
+                log.ok(`Open ${label} updated: ${existing.url}`);
+                log.info(dim("MR/PR URL is on the host — not written to TASK md (use task merge)."));
+                return { ok: true, mergeRequestUrl: existing.url, pushed: true };
+            }
+        }
         log.error(`Could not create merge request: ${msg}`);
         log.info(dim(`Branch was pushed. Create MR manually: ${gitCtx.taskBranch} → ${gitCtx.baseBranch}`));
         return { ok: false, pushed: true };

package/package.json

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