@goodtek/vibeops 1.1.2 → 2.0.0

package/CHANGELOG.md

@@ -4,6 +4,30 @@ All notable changes to VibeOps are documented here.
 
 ## Unreleased
 
+## 2.0.0 - 2026-06-03
+
+### Breaking
+
+- **TASK lifecycle commands renamed and split:** `task done` removed. Use **`task ship`** (submit: commit, push, PR, Status → Review), **`task merge`** (merge PR into integration), **`task sync`** (integration pull, Status → Done, branch cleanup), **`task release`** (integration → production PR).
+- Daily commands: `init`, `task add`, `task ship`, `task merge`, `task sync`, `status`, `llm`. Optional: `task release`.
+
+### Added
+
+- **`vibeops task merge`** — default `gh pr merge` / `glab mr merge` (squash unless `--merge` / `--rebase`); `--dry-run`.
+- **`vibeops task release`** — develop → main (or configured branches) release PR + merge; noop when trunk policy.
+
+### Changed
+
+- **`task ship`** replaces `task done`: Done status and `doneAt` are set on **`task sync`** on the integration branch, not at ship time.
+- **`status`** next hints: ship → merge → sync.
+- Templates and Cursor rules reference ship / merge / sync (rule file `03-docs-before-ship.mdc`).
+
+## 1.1.3 - 2026-06-03
+
+### Added
+
+- **`vibeops task sync [TASK-NNN]`** — after the MR is merged on the host: `git fetch --prune`, fast-forward the integration branch (e.g. `develop`), delete the local task branch (`-d`, or `-D` with `--force`), and optionally delete the remote task branch (`--no-remote-delete` to skip). Resolves the task branch from the current `task/*` checkout, the latest Done TASK, or an explicit ref.
+
 ## 1.1.2 - 2026-06-03
 
 ### Fixed

package/README.md

@@ -5,7 +5,7 @@
 [![npm version](https://img.shields.io/npm/v/@goodtek/vibeops.svg)](https://www.npmjs.com/package/@goodtek/vibeops)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
 
-VibeOps bootstraps an **agent-friendly repo**, starts numbered **TASK** files on Git branches, and closes them while updating **project memory** in Git. You plan and implement in your chosen agent; the CLI handles files, Git, and short LLM assists.
+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.
 
 ## Commands
 
@@ -13,7 +13,10 @@ 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 done` | LLM summary, push branch, open MR/PR (no local merge) |
+| `vibeops task ship` | LLM summary, commit, push, open MR/PR (Status → Review) |
+| `vibeops task merge` | Merge TASK MR/PR into integration branch (default: squash) |
+| `vibeops task sync` | After merge: update integration branch, mark Done, delete task branch |
+| `vibeops task release` | Release PR: integration → production (GitFlow) |
 | `vibeops status` | Briefing: TASK, Git, LLM, clients |
 | `vibeops llm` | Connect LLM providers (`connect` · `status` · `use`) |
 
@@ -45,17 +48,25 @@ Re-init **overwrites** templates (rules, skills, doc stubs). **`docs/tasks/TASK-
 vibeops init --clients cursor --git --initial-commit
 
 vibeops task add
-# Plan / build using your agent and the current TASK file
+# Plan / build in Cursor (@docs/tasks/TASK-NNN-*.md)
 
-vibeops task done
-vibeops status
+vibeops task ship
+vibeops task merge
+vibeops task sync
+vibeops task add
+```
+
+Occasionally (GitFlow release to production):
+
+```bash
+vibeops task release
 ```
 
-If a TASK is **In Progress**, `task add` exits with a guide — it does not auto-run `task done`.
+If a TASK is **In Progress** or **Review**, `task add` exits with a guide.
 
 ## LLM (optional)
 
-For **`task add`** / **`task done`** only (not for coding in the IDE):
+For **`task add`** / **`task ship`** only (not for coding in the IDE):
 
 ```bash
 vibeops llm connect
@@ -80,16 +91,21 @@ 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 done`**: `--dry-run`, `--no-pr` (push only)
+- **`task ship`**: `--dry-run`, `--no-pr`
+- **`task merge`**: `--dry-run`, `--merge`, `--rebase`
+- **`task sync`**: `--dry-run`, `--no-remote-delete`, `--force`
+- **`task release`**: `--dry-run`, `--no-merge`, `--merge`, `--rebase`
 - **`status`**: `--json`
 
 ## Git
 
 - **Init** records branch policy in `.vibeops.json` (`integrationBranch`, `productionBranch`, `host`).
-- **`task add`**: branch `task/<slug>` from the **integration** branch (e.g. `develop`).
-- **`task done`**: commit implementation → `git push` → `gh pr create` / `glab mr create` → commit TASK closure (Status Done, Git Context) → push again. **You merge on GitHub/GitLab**; CI deploys.
-- Commit messages: `feat(task-nnn): …`
-- No force-push to shared branches
+- **`task add`**: `task/<slug>` from **integration** (e.g. `develop`).
+- **`task ship`**: commit → push → MR/PR → Status **Review** on task branch.
+- **`task merge`**: merge MR/PR into integration (CLI default: squash).
+- **`task sync`**: integration ff-only pull → Status **Done** → delete `task/*` branches.
+- **`task release`**: integration → production PR + merge (skipped on trunk policy).
+- No force-push to shared branches.
 
 ## License
 

package/dist/bootstrap/installer.js

@@ -12,7 +12,7 @@ function envExampleContents() {
         "# VibeOps · optional environment",
         "# Copy to .vibeops.env (gitignored). Never commit secrets.",
         "#",
-        "# LLM for task add / task done (optional — Codex OAuth and Cursor Agent CLI also work):",
+        "# LLM for task add / task ship (optional — Codex OAuth and Cursor Agent CLI also work):",
         "# OPENAI_API_KEY=",
         "",
     ].join("\n");

package/dist/cli.js

@@ -4,13 +4,16 @@ 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 { taskDoneCommand } from "./commands/task-done.js";
+import { taskMergeCommand } from "./commands/task-merge.js";
+import { taskReleaseCommand } from "./commands/task-release.js";
+import { taskShipCommand } from "./commands/task-ship.js";
+import { taskSyncCommand } from "./commands/task-sync.js";
 import { loadVibeopsEnv } from "./lib/env.js";
 import { VERSION } from "./version.js";
 const program = new Command();
 program
     .name("vibeops")
-    .description("VibeOps v3 — Cursor-friendly TASK workflow (init · task · status · llm)")
+    .description("VibeOps — TASK workflow (init · task add/ship/merge/sync · status · llm)")
     .version(VERSION, "-v, --version", "Print the VibeOps version");
 program.hook("preAction", async (_thisCommand, actionCommand) => {
     const opts = actionCommand.opts();
@@ -53,10 +56,10 @@ program
         gitHost: opts.gitHost,
     });
 });
-const task = program.command("task").description("TASK lifecycle");
+const task = program.command("task").description("TASK lifecycle (add · ship · merge · sync · release)");
 task
     .command("add")
-    .description("Create next TASK-NNN, task branch, In Progress (guide-only if one is open)")
+    .description("Create next TASK-NNN, task branch, In Progress")
     .option("--dry-run", "Plan only")
     .option("--non-interactive", "CI: minimal scaffold (optional --idea)")
     .option("--idea <text>", "Short description (CI)")
@@ -70,18 +73,65 @@ task
     });
 });
 task
-    .command("done [taskRef]")
-    .description("Close TASK: LLM summary, push branch, open MR/PR (no local merge)")
+    .command("ship [taskRef]")
+    .description("Submit TASK: LLM summary, commit, push, open MR/PR (Status → Review)")
     .option("--dry-run", "Plan only")
     .option("--no-pr", "Push only; skip creating MR/PR")
     .option("--cwd <path>", "Target directory")
     .action(async (taskRef, opts) => {
-    await taskDoneCommand(taskRef, {
+    await taskShipCommand(taskRef, {
         dryRun: Boolean(opts.dryRun),
         noPr: Boolean(opts.noPr),
         cwd: opts.cwd,
     });
 });
+task
+    .command("merge [taskRef]")
+    .description("Merge TASK MR/PR into integration branch (default: squash)")
+    .option("--dry-run", "Plan only")
+    .option("--merge", "Merge commit (instead of squash)")
+    .option("--rebase", "Rebase merge")
+    .option("--cwd <path>", "Target directory")
+    .action(async (taskRef, opts) => {
+    await taskMergeCommand(taskRef, {
+        dryRun: Boolean(opts.dryRun),
+        merge: Boolean(opts.merge),
+        rebase: Boolean(opts.rebase),
+        cwd: opts.cwd,
+    });
+});
+task
+    .command("sync [taskRef]")
+    .description("After MR merge: update integration branch, mark Done, delete task branch")
+    .option("--dry-run", "Plan only")
+    .option("--no-remote-delete", "Keep the task branch on the remote")
+    .option("--force", "Delete local task branch with -D if not fully merged")
+    .option("--cwd <path>", "Target directory")
+    .action(async (taskRef, opts) => {
+    await taskSyncCommand(taskRef, {
+        dryRun: Boolean(opts.dryRun),
+        noRemoteDelete: Boolean(opts.noRemoteDelete),
+        force: Boolean(opts.force),
+        cwd: opts.cwd,
+    });
+});
+task
+    .command("release")
+    .description("Open (and merge) release MR/PR: integration branch → production")
+    .option("--dry-run", "Plan only")
+    .option("--no-merge", "Create release PR only")
+    .option("--merge", "Merge commit (instead of squash)")
+    .option("--rebase", "Rebase merge")
+    .option("--cwd <path>", "Target directory")
+    .action(async (opts) => {
+    await taskReleaseCommand({
+        dryRun: Boolean(opts.dryRun),
+        noMerge: Boolean(opts.noMerge),
+        merge: Boolean(opts.merge),
+        rebase: Boolean(opts.rebase),
+        cwd: opts.cwd,
+    });
+});
 program
     .command("status")
     .description("Briefing: active TASK, Git, LLM, next hint")
@@ -93,7 +143,7 @@ program
         cwd: opts.cwd,
     });
 });
-const llm = program.command("llm").description("LLM providers for task add / task done");
+const llm = program.command("llm").description("LLM providers for task add / task ship");
 llm
     .command("connect")
     .description("Interactive menu: connect providers and choose default")

package/dist/commands/init.js

@@ -124,14 +124,14 @@ function printNextSteps(clients, git) {
     if (!clients.includes("cursor") && !clients.includes("claude") && !clients.includes("codex")) {
         log.info("  2. Open the current TASK file in your agent before coding");
     }
-    log.info(`  3. ${cyan("vibeops llm connect")} — LLM for task add / task done`);
+    log.info(`  3. ${cyan("vibeops llm connect")} — LLM for task add / task ship`);
     log.info("  4. Push branches to origin (first time only):");
     log.info(`     ${dim(`git push -u ${git.remote} ${git.productionBranch}`)}`);
     if (git.integrationBranch !== git.productionBranch) {
         log.info(`     ${dim(`git push -u ${git.remote} ${git.integrationBranch}`)}`);
     }
     log.info(`  5. ${cyan("vibeops task add")} — branches from ${git.integrationBranch} (pulls latest first)`);
-    log.info(`  6. ${cyan("vibeops task done")} — push + open MR/PR; merge on ${git.host} (CI deploys)`);
+    log.info(`  6. ${cyan("vibeops task ship")} → merge → sync — TASK lifecycle on ${git.host}`);
 }
 export async function initCommand(options = {}) {
     const dryRun = options.dryRun === true;
@@ -272,7 +272,7 @@ export async function initCommand(options = {}) {
     if (!dryRun) {
         await writeConfig(projectRoot, buildConfig(name, clients, gitConfig, existingConfig));
         if (options.allowNoRemote === true && remote === null) {
-            log.warn("No git remote configured (--allow-no-remote). task done push/MR will fail until origin exists.");
+            log.warn("No git remote configured (--allow-no-remote). task ship push/MR will fail until origin exists.");
         }
         printNextSteps(clients, gitConfig);
     }

package/dist/commands/llm.js

@@ -71,7 +71,7 @@ export async function llmUseCommand(providerArg, opts = {}) {
             })),
         ];
         preference = await select({
-            message: "Default LLM for task add / task done",
+            message: "Default LLM for task add / task ship",
             choices,
             loop: false,
         });
@@ -99,7 +99,7 @@ export async function llmConnectCommand(opts = {}) {
         return;
     }
     log.info(bold("vibeops llm connect"));
-    log.info(dim("Set up providers, then pick which one task add / task done use."));
+    log.info(dim("Set up providers, then pick which one task add / task ship use."));
     log.blank();
     let done = false;
     while (!done) {
@@ -116,7 +116,7 @@ export async function llmConnectCommand(opts = {}) {
         const action = await select({
             message: "LLM setup",
             choices: [
-                { name: "Choose default provider (task add / task done)", value: "pick" },
+                { name: "Choose default provider (task add / task ship)", value: "pick" },
                 { name: "Set up Cursor Agent CLI (`agent login`)", value: "setup-cursor" },
                 { name: "Show Codex OAuth setup (`codex login`)", value: "setup-codex" },
                 { name: "Set up OpenAI API key (.vibeops.env)", value: "setup-openai" },

package/dist/commands/status.js

@@ -62,6 +62,7 @@ async function buildReport(cwd) {
         resultFilled,
         testFilled,
         onTaskBranch,
+        hasMergeRequest: typeof mergeRequestUrl === "string" && mergeRequestUrl.length > 0,
     });
     const llm = isVibeopsProject ? await buildLlmStatusReport(cwd) : null;
     return {

package/dist/commands/task-add.js

@@ -44,7 +44,7 @@ export async function taskAddCommand(opts = {}) {
         }
         log.info(`  ${dim("file")}   ${relPath(root, blocking.filePath)}`);
         log.blank();
-        log.info(`Finish it first: ${cyan(`vibeops task done ${blocking.id}`)}`);
+        log.info(`Finish it first: ${cyan(`vibeops task sync ${blocking.id}`)} (after ship + merge)`);
         log.info(`Then run ${cyan("vibeops task add")} again.`);
         process.exitCode = 1;
         return;
@@ -123,5 +123,5 @@ export async function taskAddCommand(opts = {}) {
     log.info(bold("Next in Cursor"));
     log.info(`  Ask:  @${relFile} — plan Scope / Acceptance Criteria`);
     log.info(`  Agent: same file — implement`);
-    log.info(`  Done: ${cyan(`vibeops task done ${taskId}`)}`);
+    log.info(`  Ship: ${cyan(`vibeops task ship ${taskId}`)}`);
 }

package/dist/commands/task-merge.js

@@ -0,0 +1,134 @@
+import { resolve } from "node:path";
+import { GitConfigError, requireGitConfig } from "../lib/git-config.js";
+import { detectGitHost, mergeRequestLabel } from "../lib/git-host.js";
+import { gitRemoteUrl } from "../lib/git.js";
+import { bold, cyan, dim, log } from "../lib/logger.js";
+import { projectPaths } from "../lib/paths.js";
+import { taskNotFoundMessage } from "../lib/resolve-task.js";
+import { getMergeRequestState, mergeMergeRequest, probeMergeRequestCli, } from "../lib/pr-create.js";
+import { relPath } from "../lib/task-context.js";
+import { resolveLifecycleTarget } from "../lib/task-lifecycle-target.js";
+import { readGitContext } from "../lib/task.js";
+function resolveMergeMethod(opts) {
+    if (opts.rebase === true)
+        return "rebase";
+    if (opts.merge === true)
+        return "merge";
+    return "squash";
+}
+export async function taskMergeCommand(taskRef, options = {}) {
+    const cwd = resolve(options.cwd ?? process.cwd());
+    const dryRun = options.dryRun === true;
+    const paths = projectPaths(cwd);
+    let gitCfg;
+    try {
+        gitCfg = await requireGitConfig(cwd);
+    }
+    catch (e) {
+        if (e instanceof GitConfigError) {
+            log.error(e.message);
+            process.exitCode = 1;
+            return;
+        }
+        throw e;
+    }
+    const target = await resolveLifecycleTarget(paths, cwd, taskRef);
+    if (target === null) {
+        if (taskRef?.trim()) {
+            log.error(taskNotFoundMessage(taskRef));
+        }
+        else {
+            log.error("No TASK to merge. Pass TASK-NNN, checkout a task/* branch, or run task ship first.");
+        }
+        process.exitCode = 1;
+        return;
+    }
+    const ctx = await readGitContext(target.taskFile);
+    if (ctx === null) {
+        log.error("No Git Context on TASK — run task add first.");
+        process.exitCode = 1;
+        return;
+    }
+    if (!ctx.mergeRequestUrl) {
+        if (dryRun) {
+            log.info(dim(`would merge ${ctx.taskBranch} → ${ctx.baseBranch} after MR exists (run task ship)`));
+            log.blank();
+            log.info(`Next: ${cyan("vibeops task sync")}`);
+            return;
+        }
+        log.error("No Merge Request URL on TASK — run task ship first.");
+        process.exitCode = 1;
+        return;
+    }
+    const remoteUrl = await gitRemoteUrl(cwd, gitCfg.remote);
+    const host = remoteUrl !== null && detectGitHost(remoteUrl) !== null
+        ? detectGitHost(remoteUrl)
+        : gitCfg.host;
+    const method = resolveMergeMethod(options);
+    const label = mergeRequestLabel(host);
+    log.info(bold(`vibeops task merge ${target.taskId}`));
+    log.info(`  ${dim("file")}       ${relPath(cwd, target.taskFile)}`);
+    log.info(`  ${dim("MR/PR")}      ${ctx.mergeRequestUrl}`);
+    log.info(`  ${dim("target")}     ${ctx.baseBranch} (${gitCfg.integrationBranch})`);
+    log.info(`  ${dim("method")}     ${method}`);
+    log.blank();
+    if (dryRun) {
+        await mergeMergeRequest({
+            cwd,
+            host,
+            url: ctx.mergeRequestUrl,
+            method,
+            dryRun: true,
+        });
+        log.blank();
+        log.info(`Next: ${cyan("vibeops task sync")}`);
+        return;
+    }
+    const state = await getMergeRequestState(cwd, host, ctx.mergeRequestUrl);
+    if (state === "merged") {
+        log.ok(`${label} already merged.`);
+        log.blank();
+        log.info(`Next: ${cyan("vibeops task sync")}`);
+        return;
+    }
+    if (state === "open") {
+        const cliOk = await probeMergeRequestCli(host);
+        if (!cliOk) {
+            const tool = host === "gitlab" ? "glab" : "gh";
+            log.error(`${tool} CLI not found — merge in the host UI, then task sync.`);
+            process.exitCode = 1;
+            return;
+        }
+        try {
+            await mergeMergeRequest({ cwd, host, url: ctx.mergeRequestUrl, method });
+            log.ok(`${label} merged into ${ctx.baseBranch}.`);
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            log.error(`Merge failed: ${msg}`);
+            log.info(dim("Merge in the host UI if branch protection blocks CLI merge."));
+            process.exitCode = 1;
+            return;
+        }
+    }
+    else if (state === "closed") {
+        log.warn(`${label} is closed but not merged — resolve manually.`);
+        process.exitCode = 1;
+        return;
+    }
+    else {
+        log.warn(`Could not read ${label} state — attempting merge anyway.`);
+        try {
+            await mergeMergeRequest({ cwd, host, url: ctx.mergeRequestUrl, method });
+            log.ok(`${label} merge command completed.`);
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            log.error(`Merge failed: ${msg}`);
+            process.exitCode = 1;
+            return;
+        }
+    }
+    log.blank();
+    log.info(`Next: ${cyan("vibeops task sync")}`);
+}

package/dist/commands/task-release.js

@@ -0,0 +1,103 @@
+import { resolve } from "node:path";
+import { GitConfigError, requireGitConfig } from "../lib/git-config.js";
+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, mergeMergeRequest, probeMergeRequestCli, } from "../lib/pr-create.js";
+function resolveMergeMethod(opts) {
+    if (opts.rebase === true)
+        return "rebase";
+    if (opts.merge === true)
+        return "merge";
+    return "squash";
+}
+export async function taskReleaseCommand(options = {}) {
+    const cwd = resolve(options.cwd ?? process.cwd());
+    const dryRun = options.dryRun === true;
+    let gitCfg;
+    try {
+        gitCfg = await requireGitConfig(cwd);
+    }
+    catch (e) {
+        if (e instanceof GitConfigError) {
+            log.error(e.message);
+            process.exitCode = 1;
+            return;
+        }
+        throw e;
+    }
+    const { integrationBranch, productionBranch, remote } = gitCfg;
+    if (integrationBranch === productionBranch) {
+        log.info("Trunk policy: integration and production are the same branch — no release PR step.");
+        return;
+    }
+    const remoteUrl = await gitRemoteUrl(cwd, remote);
+    const host = remoteUrl !== null && detectGitHost(remoteUrl) !== null
+        ? detectGitHost(remoteUrl)
+        : gitCfg.host;
+    const label = mergeRequestLabel(host);
+    const title = `Release: ${integrationBranch} → ${productionBranch}`;
+    const body = [
+        `Integrate \`${integrationBranch}\` into \`${productionBranch}\`.`,
+        "",
+        "Opened by `vibeops task release`.",
+    ].join("\n");
+    log.info(bold("vibeops task release"));
+    log.info(`  ${dim("head")}   ${integrationBranch}`);
+    log.info(`  ${dim("base")}   ${productionBranch}`);
+    log.blank();
+    if (dryRun) {
+        log.info(bold("dry-run — would:"));
+        log.info(`  · ${label}: ${integrationBranch} → ${productionBranch}`);
+        if (options.noMerge !== true) {
+            log.info(`  · merge ${label} (${resolveMergeMethod(options)})`);
+        }
+        return;
+    }
+    const cliOk = await probeMergeRequestCli(host);
+    if (!cliOk) {
+        const tool = host === "gitlab" ? "glab" : "gh";
+        log.error(`${tool} CLI not found — create the release ${label} manually.`);
+        process.exitCode = 1;
+        return;
+    }
+    let releaseUrl;
+    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;
+    }
+    const state = await getMergeRequestState(cwd, host, releaseUrl);
+    if (state === "merged") {
+        log.ok(`Release ${label} already merged.`);
+        return;
+    }
+    const method = resolveMergeMethod(options);
+    try {
+        await mergeMergeRequest({ cwd, host, url: releaseUrl, method });
+        log.ok(`Release ${label} merged into ${productionBranch}.`);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        log.error(`Release merge failed: ${msg}`);
+        log.info(dim(`Complete merge in the host UI: ${releaseUrl}`));
+        process.exitCode = 1;
+    }
+}