@goodtek/vibeops 2.1.0 → 2.1.1

package/CHANGELOG.md

@@ -4,6 +4,19 @@ All notable changes to VibeOps are documented here.
 
 ## Unreleased
 
+## 2.1.1 - 2026-06-08
+
+### Changed
+
+- **Docs:** living markdown, templates, and Cursor rules aligned with 2.1 lifecycle (`task reship`, two-status model, sync does not edit TASK md).
+- **`task sync` CLI help:** description no longer says "mark Done".
+
+## 2.1.0 - 2026-06-03
+
+### Added
+
+- **`vibeops task reship [TASK-NNN]`** — follow-up on a **Shipped** TASK: integrate develop, archive prior MR, new MR/PR; Status stays **Shipped**.
+
 ### Changed
 
 - **TASK md status:** only **In Progress** → **Shipped** (`task ship`). Merge (CLI/UI) and **`task sync`** do not edit the TASK file.

package/README.md

@@ -14,6 +14,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 ship` | LLM summary, commit, push, open MR/PR (Status → **Shipped**) |
+| `vibeops task reship` | Shipped TASK follow-up: integrate develop, new MR/PR (Status stays 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) |
@@ -52,6 +53,9 @@ vibeops task add
 
 vibeops task ship
 vibeops task merge
+# Follow-up on same TASK (after merge):
+vibeops task reship TASK-NNN
+vibeops task merge
 vibeops task sync
 vibeops task add
 ```
@@ -66,7 +70,7 @@ Only one TASK **In Progress** at a time (`task add` blocks otherwise). **Shipped
 
 ## LLM (optional)
 
-For **`task add`** / **`task ship`** only (not for coding in the IDE):
+For **`task add`** / **`task ship`** / **`task reship`** only (not for coding in the IDE):
 
 ```bash
 vibeops llm connect
@@ -92,6 +96,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 ship`**: `--dry-run`, `--no-pr`
+- **`task reship`**: `--dry-run`, `--no-pr`, `--no-integrate`, `--recreate-branch`, `--skip-llm`, `--allow-open-mr`, `--allow-dirty`
 - **`task merge`**: `--dry-run`, `--merge`, `--rebase`
 - **`task sync`**: `--dry-run`, `--no-remote-delete`, `--force`
 - **`task release`**: `--dry-run`, `--no-merge`, `--merge`, `--rebase`
@@ -102,6 +107,7 @@ pnpm install && pnpm build && pnpm smoke
 - **Init** records branch policy in `.vibeops.json` (`integrationBranch`, `productionBranch`, `host`).
 - **`task add`**: `task/<slug>` from **integration** (e.g. `develop`).
 - **`task ship`**: commit → push → MR/PR → Status **Shipped** on task branch.
+- **`task reship`**: Shipped TASK only; integrates `develop`; opens **new** PR (archives previous MR in Git Context).
 - **`task merge`**: merge MR/PR into integration (CLI or host UI; TASK md unchanged).
 - **`task sync`**: integration ff-only pull → delete `task/*` branches (TASK md unchanged).
 - **`task release`**: integration → production PR + merge (skipped on trunk policy).

package/dist/cli.js

@@ -7,13 +7,14 @@ import { taskAddCommand } from "./commands/task-add.js";
 import { taskMergeCommand } from "./commands/task-merge.js";
 import { taskReleaseCommand } from "./commands/task-release.js";
 import { taskShipCommand } from "./commands/task-ship.js";
+import { taskReshipCommand } from "./commands/task-reship.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 — TASK workflow (init · task add/ship/merge/sync · status · llm)")
+    .description("VibeOps — TASK workflow (init · task add/ship/reship/merge/sync · status · llm)")
     .version(VERSION, "-v, --version", "Print the VibeOps version");
 program.hook("preAction", async (_thisCommand, actionCommand) => {
     const opts = actionCommand.opts();
@@ -56,7 +57,7 @@ program
         gitHost: opts.gitHost,
     });
 });
-const task = program.command("task").description("TASK lifecycle (add · ship · merge · sync · release)");
+const task = program.command("task").description("TASK lifecycle (add · ship · reship · merge · sync · release)");
 task
     .command("add")
     .description("Create next TASK-NNN, task branch, In Progress")
@@ -74,7 +75,7 @@ task
 });
 task
     .command("ship [taskRef]")
-    .description("Submit TASK: LLM summary, commit, push, open MR/PR (Status → Review)")
+    .description("Submit TASK: LLM summary, commit, push, open MR/PR (Status → Shipped)")
     .option("--dry-run", "Plan only")
     .option("--no-pr", "Push only; skip creating MR/PR")
     .option("--cwd <path>", "Target directory")
@@ -85,6 +86,29 @@ task
         cwd: opts.cwd,
     });
 });
+task
+    .command("reship [taskRef]")
+    .description("Follow-up on Shipped TASK: integrate develop, commit, new MR/PR")
+    .option("--dry-run", "Plan only")
+    .option("--no-pr", "Push only; skip creating MR/PR")
+    .option("--no-integrate", "Skip merging integration branch into task branch")
+    .option("--recreate-branch", "Recreate task branch from integration if missing")
+    .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-dirty", "Proceed when only governance paths are dirty")
+    .option("--cwd <path>", "Target directory")
+    .action(async (taskRef, opts) => {
+    await taskReshipCommand(taskRef, {
+        dryRun: Boolean(opts.dryRun),
+        noPr: Boolean(opts.noPr),
+        noIntegrate: Boolean(opts.noIntegrate),
+        recreateBranch: Boolean(opts.recreateBranch),
+        skipLlm: Boolean(opts.skipLlm),
+        allowOpenMr: Boolean(opts.allowOpenMr),
+        allowDirty: Boolean(opts.allowDirty),
+        cwd: opts.cwd,
+    });
+});
 task
     .command("merge [taskRef]")
     .description("Merge TASK MR/PR into integration branch (default: squash)")
@@ -102,7 +126,7 @@ task
 });
 task
     .command("sync [taskRef]")
-    .description("After MR merge: update integration branch, mark Done, delete task branch")
+    .description("After MR merge: integration pull and delete task branch (TASK md unchanged)")
     .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")

package/dist/commands/status.js

@@ -70,6 +70,7 @@ async function buildReport(cwd) {
         hasMergeRequest: typeof mergeRequestUrl === "string" && mergeRequestUrl.length > 0,
         mergeRequestMerged,
         needsSync,
+        hasLocalChanges: git.dirty === true,
     });
     const llm = isVibeopsProject ? await buildLlmStatusReport(cwd) : null;
     return {

package/dist/commands/task-reship.js

@@ -0,0 +1,192 @@
+import { resolve } from "node:path";
+import { readText } from "../lib/filesystem.js";
+import { bold, cyan, dim, green, log, yellow } from "../lib/logger.js";
+import { projectPaths } from "../lib/paths.js";
+import { relPath } from "../lib/task-context.js";
+import { commitDirtyWorkingTree, docsCommitMessageFor, featCommitMessageFor, pushBranch, } from "../lib/task-git-commit.js";
+import { finishTaskWithPullRequest } from "../lib/task-push-pr.js";
+import { applyTaskShipMemory, llmCompleteTaskReship, writeTaskResultSections, } from "../lib/task-ship-llm.js";
+import { assertMergeRequestNotOpen, ensureTaskBranchForReship, integrateIntegrationIntoTaskBranch, loadGitConfigForReship, prepareGitContextForReship, refreshGitContextBaseCommit, resolveReshipTarget, } from "../lib/task-reship.js";
+import { hasNonEmptySection, parseTaskFilename, readGitContext, upsertGitContext, } from "../lib/task.js";
+import { listWorkingTreeRelPaths } from "../lib/git.js";
+async function commitReshipMetadataAndPush(opts) {
+    if (opts.dryRun) {
+        log.info(dim("  would commit reship metadata (Status stays Shipped)"));
+        if (opts.push !== null) {
+            log.info(dim(`  would git push ${opts.push.remote} ${opts.push.branch} (reship metadata)`));
+        }
+        return true;
+    }
+    const committed = await commitDirtyWorkingTree(opts.cwd, docsCommitMessageFor(opts.taskId, "reship metadata"), false);
+    if (!committed) {
+        log.info(dim("No reship metadata commit (Git Context already on disk)."));
+    }
+    if (opts.push === null)
+        return true;
+    try {
+        await pushBranch(opts.cwd, opts.push.remote, opts.push.branch, false);
+        log.ok(`Pushed reship metadata → ${opts.push.remote}/${opts.push.branch}`);
+        return true;
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        log.error(`Reship metadata push failed: ${msg}`);
+        return false;
+    }
+}
+export async function taskReshipCommand(taskRef, options = {}) {
+    const cwd = resolve(options.cwd ?? process.cwd());
+    const paths = projectPaths(cwd);
+    const dryRun = options.dryRun === true;
+    const target = await resolveReshipTarget(paths, cwd, taskRef);
+    if (target === null) {
+        process.exitCode = 1;
+        return;
+    }
+    const { taskId, taskFile, meta, gitCtx: initialCtx } = target;
+    const relFile = relPath(cwd, taskFile);
+    log.info(bold(`vibeops task reship ${taskId}`));
+    log.info(`  ${dim("file")}    ${relFile}`);
+    log.info(`  ${dim("branch")}  ${initialCtx.taskBranch}`);
+    log.info(`  ${dim("status")}  Shipped (unchanged)`);
+    log.blank();
+    const gitCfg = dryRun
+        ? await loadGitConfigForReship(cwd).catch(() => null)
+        : await loadGitConfigForReship(cwd);
+    if (!dryRun && gitCfg === null) {
+        process.exitCode = 1;
+        return;
+    }
+    const integrationBranch = gitCfg?.integrationBranch ?? "develop";
+    const remote = gitCfg?.remote ?? "origin";
+    if (!dryRun && !(await assertMergeRequestNotOpen(cwd, taskFile, options.allowOpenMr === true))) {
+        process.exitCode = 1;
+        return;
+    }
+    const branchOk = await ensureTaskBranchForReship({
+        cwd,
+        taskFile,
+        gitCtx: initialCtx,
+        integrationBranch,
+        remote,
+        recreateBranch: options.recreateBranch === true,
+        dryRun,
+        allowDirty: options.allowDirty === true,
+    });
+    if (!branchOk) {
+        process.exitCode = 1;
+        return;
+    }
+    if (options.noIntegrate !== true) {
+        const integrated = await integrateIntegrationIntoTaskBranch({
+            cwd,
+            integrationBranch,
+            remote,
+            dryRun,
+        });
+        if (!integrated) {
+            process.exitCode = 1;
+            return;
+        }
+    }
+    else {
+        log.info(dim("Skipped integration merge (--no-integrate)."));
+    }
+    const body = await readText(taskFile);
+    let resultOk = hasNonEmptySection(body, "Result");
+    let testOk = hasNonEmptySection(body, "Test Result");
+    if (!options.skipLlm && !dryRun) {
+        log.step("LLM — follow-up Result / Test Result");
+        const patch = await llmCompleteTaskReship({
+            cwd,
+            taskId,
+            taskTitle: meta.title,
+            taskBody: body,
+            taskFileRel: relFile,
+        });
+        if (patch !== null) {
+            await writeTaskResultSections(taskFile, patch.result, patch.testResult);
+            log.ok(`Result / Test Result updated (${patch.provider})`);
+            const memory = await applyTaskShipMemory(cwd, patch);
+            for (const p of memory.updated)
+                log.ok(`Updated ${p}`);
+            for (const p of memory.skipped)
+                log.skip(`Skipped ${p}`);
+        }
+        else {
+            log.warn("LLM unavailable — ensure Result / Test Result describe this follow-up.");
+        }
+        const body2 = await readText(taskFile);
+        resultOk = hasNonEmptySection(body2, "Result");
+        testOk = hasNonEmptySection(body2, "Test Result");
+    }
+    else if (options.skipLlm) {
+        log.info(dim("LLM skipped (--skip-llm)."));
+    }
+    log.info(bold("Sections"));
+    log.info(`  ${resultOk ? green("✓") : yellow("·")} Result`);
+    log.info(`  ${testOk ? green("✓") : yellow("·")} Test Result`);
+    log.blank();
+    if (dryRun) {
+        log.info(bold("dry-run — would also:"));
+        log.info("  · archive prior MR URL; open new MR/PR (unless --no-pr)");
+        log.info("  · feat commit + reship metadata push");
+        log.blank();
+        log.info(`Next: ${cyan("vibeops task merge")}, then optional ${cyan("task sync")}`);
+        return;
+    }
+    if (!resultOk || !testOk) {
+        log.error("Fill Result and Test Result for this follow-up, then rerun.");
+        process.exitCode = 1;
+        return;
+    }
+    const dirtyBefore = await listWorkingTreeRelPaths(cwd);
+    if (dirtyBefore.length === 0) {
+        log.error("No changes to reship. Edit files on the task branch, then rerun.");
+        process.exitCode = 1;
+        return;
+    }
+    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.");
+        process.exitCode = 1;
+        return;
+    }
+    gitCtx = await refreshGitContextBaseCommit(taskFile, gitCtx, cwd);
+    gitCtx = await prepareGitContextForReship(taskFile, gitCtx);
+    await upsertGitContext(taskFile, gitCtx);
+    const prResult = await finishTaskWithPullRequest({
+        cwd,
+        taskFile,
+        skipPr: options.noPr === true,
+        forceNewMergeRequest: true,
+    });
+    if (!prResult.ok) {
+        log.error("Reship failed — fix push/MR, then rerun task reship.");
+        process.exitCode = 1;
+        return;
+    }
+    if (prResult.mergeRequestUrl) {
+        log.info(`  ${dim("MR/PR")}     ${prResult.mergeRequestUrl}`);
+    }
+    const gitCtxAfter = await readGitContext(taskFile);
+    let pushTarget = null;
+    if (gitCtxAfter !== null && gitCfg !== null) {
+        pushTarget = { remote: gitCfg.remote, branch: gitCtxAfter.taskBranch };
+    }
+    const pushed = await commitReshipMetadataAndPush({
+        cwd,
+        taskFile,
+        taskId: parts.id,
+        dryRun: false,
+        push: pushTarget,
+    });
+    if (!pushed) {
+        process.exitCode = 1;
+        return;
+    }
+    log.blank();
+    log.info(`Next: ${cyan("vibeops task merge")} (or merge in the host UI), then ${cyan("vibeops task sync")}`);
+}

package/dist/lib/git.js

@@ -505,6 +505,10 @@ export async function gitDeleteRemoteBranch(cwd, remote, branch) {
 export async function gitPullFastForwardOnly(cwd, remote, branch) {
     await runGit(cwd, ["pull", "--ff-only", remote, branch]);
 }
+/** 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"]);
+}
 export async function gitPush(cwd, remote, branch, setUpstream = true) {
     const args = setUpstream ? ["push", "-u", remote, branch] : ["push", remote, branch];
     await runGit(cwd, args);

package/dist/lib/task-context.js

@@ -48,6 +48,8 @@ export function computeNextHint(input) {
             return "task-sync";
         if (input.hasMergeRequest && !input.mergeRequestMerged)
             return "task-merge";
+        if (input.hasLocalChanges && input.onTaskBranch === true)
+            return "task-reship";
         return "task-add";
     }
     if (!input.resultFilled || !input.testFilled) {
@@ -63,6 +65,10 @@ export function hintToText(hint, cwd, task) {
             return "Run `vibeops task add` to start the next slice.";
         case "task-ship":
             return task ? `Run \`vibeops task ship ${task.id}\`.` : "Run `vibeops task ship`.";
+        case "task-reship":
+            return task
+                ? `Follow-up on ${task.id}? Edit on task branch, then \`vibeops task reship ${task.id}\`.`
+                : "Run `vibeops task reship TASK-NNN` for a Shipped follow-up.";
         case "task-merge":
             return task
                 ? `Merge the MR (UI or \`vibeops task merge ${task.id}\`), then optional task sync.`

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

@@ -59,7 +59,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.`);
     }
-    if (isExistingMergeRequestUrl(gitCtx.mergeRequestUrl)) {
+    if (isExistingMergeRequestUrl(gitCtx.mergeRequestUrl) &&
+        opts.forceNewMergeRequest !== true) {
         log.info(dim(`Merge request already recorded: ${gitCtx.mergeRequestUrl}`));
         return { ok: true, mergeRequestUrl: gitCtx.mergeRequestUrl, pushed: true };
     }

package/dist/lib/task-reship.js

@@ -0,0 +1,192 @@
+import { resolve } from "node:path";
+import { GitConfigError, requireGitConfig } from "./git-config.js";
+import { gitBranchExists, gitCheckout, gitCheckoutNewBranch, gitFetchRemote, gitGovernanceOnlyDirty, gitHeadCommit, gitMergeRemoteBranch, gitMergeInProgress, gitPullFastForwardOnly, gitRemoteBranchExists, gitSwitchToBranch, listUnmergedRelPaths, readGitInfo, } from "./git.js";
+import { dim, log } from "./logger.js";
+import { getMergeRequestStateForTask } from "./task-effective-status.js";
+import { normalizeTaskRef } from "./resolve-task.js";
+import { archiveMergeRequestForReship, findTaskFile, loadActionableTasks, pickLatestShippedTask, readGitContext, readTaskFile, upsertGitContext, } from "./task.js";
+export async function resolveReshipTarget(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 shipped = pickLatestShippedTask(await loadActionableTasks(paths.docsTasks));
+        if (shipped === null) {
+            log.error(reshipNotFoundMessage(undefined));
+            return null;
+        }
+        taskId = shipped.id;
+        taskFile = shipped.filePath;
+    }
+    if (taskFile === null) {
+        log.error(reshipNotFoundMessage(taskRef));
+        return null;
+    }
+    const meta = await readTaskFile(taskFile);
+    if (meta.status !== "shipped") {
+        log.error(`${taskId} is ${meta.status === "in_progress" ? "In Progress" : meta.status} — use \`vibeops task ship\` for first submit.`);
+        return null;
+    }
+    const gitCtx = await readGitContext(taskFile);
+    if (gitCtx === null) {
+        log.error(`No Git Context on ${taskId}. Cannot reship.`);
+        return null;
+    }
+    return { taskId, taskFile, meta, gitCtx };
+}
+export function reshipNotFoundMessage(taskRef) {
+    if (taskRef?.trim()) {
+        return `Shipped TASK not found: ${normalizeTaskRef(taskRef)}. Check docs/tasks/.`;
+    }
+    return "No Shipped TASK found. Pass `vibeops task reship TASK-NNN`.";
+}
+/** Checkout or recreate the task branch without changing TASK Status. */
+export async function ensureTaskBranchForReship(opts) {
+    const cwd = resolve(opts.cwd);
+    const { taskBranch } = opts.gitCtx;
+    const git = await readGitInfo(cwd);
+    if (!git.isRepo) {
+        log.error("Not a git repository.");
+        return false;
+    }
+    if (git.dirty === true && !opts.allowDirty) {
+        const gov = await gitGovernanceOnlyDirty(cwd);
+        if (!gov.onlyGovernance) {
+            log.error("Working tree is dirty. Commit or stash, or rerun with --allow-dirty.");
+            return false;
+        }
+        log.warn("Only governance paths are dirty — proceeding.");
+    }
+    const localExists = await gitBranchExists(cwd, taskBranch);
+    const remoteExists = await gitRemoteBranchExists(cwd, opts.remote, taskBranch);
+    if (opts.dryRun) {
+        if (localExists) {
+            log.info(dim(`  would git switch ${taskBranch}`));
+        }
+        else if (opts.recreateBranch) {
+            log.info(dim(`  would recreate ${taskBranch} from ${opts.integrationBranch}`));
+        }
+        else {
+            log.error(`Local branch ${taskBranch} missing. Rerun with --recreate-branch.`);
+            return false;
+        }
+        return true;
+    }
+    if (localExists) {
+        await gitCheckout(cwd, taskBranch);
+        log.ok(`On ${taskBranch}`);
+        return true;
+    }
+    if (!opts.recreateBranch) {
+        if (remoteExists) {
+            log.error(`Local ${taskBranch} missing. Fetch/checkout the branch or rerun with --recreate-branch.`);
+        }
+        else {
+            log.error(`Branch ${taskBranch} not found locally or on ${opts.remote}. Use --recreate-branch.`);
+        }
+        return false;
+    }
+    const ok = await gitSwitchToBranch(cwd, opts.integrationBranch, opts.remote);
+    if (!ok) {
+        log.error(`Integration branch "${opts.integrationBranch}" not found.`);
+        return false;
+    }
+    if (await gitRemoteBranchExists(cwd, opts.remote, opts.integrationBranch)) {
+        try {
+            await gitPullFastForwardOnly(cwd, opts.remote, opts.integrationBranch);
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            log.error(`Could not update ${opts.integrationBranch}: ${msg}`);
+            return false;
+        }
+    }
+    const head = await gitHeadCommit(cwd);
+    if (head === null || head.length === 0) {
+        log.error("Integration branch has no commits.");
+        return false;
+    }
+    await gitCheckoutNewBranch(cwd, taskBranch, opts.integrationBranch);
+    await upsertGitContext(opts.taskFile, {
+        ...opts.gitCtx,
+        baseBranch: opts.integrationBranch,
+        baseCommit: head,
+    });
+    log.ok(`Recreated ${taskBranch} from ${opts.integrationBranch}`);
+    return true;
+}
+/** Merge latest integration into the current task branch. */
+export async function integrateIntegrationIntoTaskBranch(opts) {
+    const cwd = resolve(opts.cwd);
+    if (opts.dryRun) {
+        log.info(dim(`  would git fetch ${opts.remote} && git merge ${opts.remote}/${opts.integrationBranch}`));
+        return true;
+    }
+    try {
+        await gitFetchRemote(cwd, opts.remote);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        log.warn(`git fetch failed (${msg}). Continuing with local refs.`);
+    }
+    if (!(await gitRemoteBranchExists(cwd, opts.remote, opts.integrationBranch))) {
+        log.warn(`No ${opts.remote}/${opts.integrationBranch} — skipped integrate.`);
+        return true;
+    }
+    try {
+        await gitMergeRemoteBranch(cwd, opts.remote, opts.integrationBranch);
+        log.ok(`Merged ${opts.remote}/${opts.integrationBranch} into task branch`);
+        return true;
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        if (await gitMergeInProgress(cwd)) {
+            const conflicts = await listUnmergedRelPaths(cwd);
+            log.error(`Merge conflict with ${opts.integrationBranch}. Resolve, commit, then rerun.`);
+            if (conflicts.length > 0) {
+                log.info(dim(`Conflicts: ${conflicts.slice(0, 8).join(", ")}`));
+            }
+        }
+        else {
+            log.error(`Could not merge ${opts.integrationBranch}: ${msg}`);
+        }
+        return false;
+    }
+}
+export async function assertMergeRequestNotOpen(cwd, taskFile, allowOpenMr) {
+    if (allowOpenMr)
+        return true;
+    const state = await getMergeRequestStateForTask(cwd, taskFile);
+    if (state !== "open")
+        return true;
+    log.error("Current MR/PR is still open. Merge or close it first, or rerun with --allow-open-mr.");
+    return false;
+}
+export async function refreshGitContextBaseCommit(taskFile, gitCtx, cwd) {
+    const head = await gitHeadCommit(cwd);
+    if (head === null || head.length === 0)
+        return gitCtx;
+    return { ...gitCtx, baseCommit: head };
+}
+export async function prepareGitContextForReship(taskFile, gitCtx) {
+    const archived = archiveMergeRequestForReship(gitCtx);
+    await upsertGitContext(taskFile, archived);
+    return archived;
+}
+export async function loadGitConfigForReship(cwd) {
+    try {
+        const cfg = await requireGitConfig(cwd);
+        return { remote: cfg.remote, integrationBranch: cfg.integrationBranch };
+    }
+    catch (e) {
+        if (e instanceof GitConfigError) {
+            log.error(e.message);
+            return null;
+        }
+        throw e;
+    }
+}

package/dist/lib/task-ship-llm.js

@@ -99,6 +99,87 @@ Be factual. Do not invent files not in the diff.`,
         return null;
     }
 }
+export async function llmCompleteTaskReship(params) {
+    const git = await readGitInfo(params.cwd);
+    let diffSummary = "";
+    if (git.isRepo) {
+        const names = await gitDiffNameOnly(params.cwd);
+        diffSummary = names.slice(0, 40).join("\n") || "(no diff vs HEAD index yet)";
+    }
+    const paths = projectPaths(params.cwd);
+    const currentState = (await readOptional(join(paths.root, PROJECT_MEMORY_FILES.currentState))) ?? "";
+    const existingResult = readSection(params.taskBody, "Result");
+    const existingTest = readSection(params.taskBody, "Test Result");
+    const messages = [
+        {
+            role: "system",
+            content: `You reship a follow-up on an already Shipped VibeOps TASK. Reply with JSON only:
+{
+  "result": "full Result section — preserve prior facts and add a ## Follow-up subsection for this pass",
+  "testResult": "full Test Result for this follow-up — commands and outcomes",
+  "currentStateMarkdown": "full replacement for docs/project/05-current-state.md OR null to skip",
+  "decisionsAppend": "markdown bullets to append under ## Decisions OR null",
+  "architectureUpdate": "full replacement for 03-architecture.md OR null if unchanged",
+  "logLine": "one line for docs/logs/YYYY-MM-DD.md"
+}
+Be factual. Do not invent files not in the diff.`,
+        },
+        {
+            role: "user",
+            content: [
+                `TASK follow-up reship: ${params.taskId} — ${params.taskTitle}`,
+                `File: ${params.taskFileRel}`,
+                "",
+                "Existing Result:",
+                existingResult || "(empty)",
+                "",
+                "Existing Test Result:",
+                existingTest || "(empty)",
+                "",
+                "Changed paths (working tree / HEAD):",
+                diffSummary,
+                "",
+                "Current project state excerpt:",
+                currentState.slice(0, 2000),
+            ].join("\n"),
+        },
+    ];
+    try {
+        const config = await readConfig(params.cwd);
+        const preference = getLlmPreferenceFromConfig(config);
+        const { text: raw, provider } = await llmCompleteJson(messages, {
+            cwd: params.cwd,
+            preference,
+        });
+        const parsed = JSON.parse(extractJsonObject(raw));
+        return {
+            result: typeof parsed.result === "string" && parsed.result.trim().length > 0
+                ? parsed.result.trim()
+                : `${existingResult}\n\n## Follow-up\n\nReship ${params.taskId}.`,
+            testResult: typeof parsed.testResult === "string" && parsed.testResult.trim().length > 0
+                ? parsed.testResult.trim()
+                : existingTest || "Follow-up verification required.",
+            currentStateMarkdown: typeof parsed.currentStateMarkdown === "string" &&
+                parsed.currentStateMarkdown.trim().length > 0
+                ? parsed.currentStateMarkdown.trim()
+                : null,
+            decisionsAppend: typeof parsed.decisionsAppend === "string" && parsed.decisionsAppend.trim().length > 0
+                ? parsed.decisionsAppend.trim()
+                : null,
+            architectureUpdate: typeof parsed.architectureUpdate === "string" &&
+                parsed.architectureUpdate.trim().length > 0
+                ? parsed.architectureUpdate.trim()
+                : null,
+            logLine: typeof parsed.logLine === "string" && parsed.logLine.trim().length > 0
+                ? parsed.logLine.trim()
+                : `${params.taskId} reship follow-up.`,
+            provider,
+        };
+    }
+    catch {
+        return null;
+    }
+}
 export async function applyTaskShipMemory(cwd, patch) {
     const paths = projectPaths(cwd);
     const updated = [];

package/dist/lib/task.js

@@ -331,6 +331,29 @@ export async function updateTaskSection(filePath, title, content) {
         await writeText(filePath, updated);
     }
 }
+function parsePreviousMergeRequestUrls(content) {
+    const lines = content.split("\n");
+    const urls = [];
+    let inBlock = false;
+    for (const line of lines) {
+        const t = line.trim();
+        if (t.startsWith("- Previous Merge Requests:")) {
+            inBlock = true;
+            continue;
+        }
+        if (inBlock) {
+            const m = /^\s*-\s+(https?:\/\/.+)$/.exec(line);
+            if (m) {
+                urls.push(m[1].trim());
+                continue;
+            }
+            if (t.startsWith("- ") && !line.startsWith("  ")) {
+                break;
+            }
+        }
+    }
+    return urls;
+}
 function renderGitContextBlock(ctx) {
     const lines = [
         `- Base Branch: \`${ctx.baseBranch}\``,
@@ -344,11 +367,39 @@ function renderGitContextBlock(ctx) {
     if (typeof ctx.mergeRequestUrl === "string" && ctx.mergeRequestUrl.length > 0) {
         lines.push(`- Merge Request: ${ctx.mergeRequestUrl}`);
     }
+    const prev = ctx.previousMergeRequestUrls ?? [];
+    if (prev.length > 0) {
+        lines.push("- Previous Merge Requests:");
+        for (const url of prev) {
+            lines.push(`  - ${url}`);
+        }
+    }
     if (typeof ctx.pushedAt === "string" && ctx.pushedAt.length > 0) {
         lines.push(`- Pushed At: \`${ctx.pushedAt}\``);
     }
+    if (typeof ctx.lastReshipAt === "string" && ctx.lastReshipAt.length > 0) {
+        lines.push(`- Last Reship At: \`${ctx.lastReshipAt}\``);
+    }
+    if (typeof ctx.reshipCount === "number" && ctx.reshipCount > 0) {
+        lines.push(`- Reship Count: \`${ctx.reshipCount}\``);
+    }
     return lines.join("\n");
 }
+/** Archive current MR URL and bump reship metadata before opening a follow-up PR. */
+export function archiveMergeRequestForReship(ctx) {
+    const previous = [...(ctx.previousMergeRequestUrls ?? [])];
+    const current = ctx.mergeRequestUrl?.trim();
+    if (typeof current === "string" && current.length > 0) {
+        previous.push(current);
+    }
+    return {
+        ...ctx,
+        previousMergeRequestUrls: previous.length > 0 ? previous : undefined,
+        mergeRequestUrl: undefined,
+        reshipCount: (ctx.reshipCount ?? 0) + 1,
+        lastReshipAt: new Date().toISOString(),
+    };
+}
 export async function upsertGitContext(filePath, ctx) {
     const raw = await readText(filePath);
     const block = renderGitContextBlock(ctx);
@@ -377,6 +428,8 @@ const GIT_CTX_RE = {
     doneAt: /^-\s+Done At:\s*`([^`]+)`/m,
     mergeRequestUrl: /^-\s+Merge Request:\s*(.+)$/m,
     pushedAt: /^-\s+Pushed At:\s*`([^`]+)`/m,
+    lastReshipAt: /^-\s+Last Reship At:\s*`([^`]+)`/m,
+    reshipCount: /^-\s+Reship Count:\s*`(\d+)`/m,
 };
 export async function markGitContextDone(filePath) {
     const ctx = await readGitContext(filePath);
@@ -398,13 +451,27 @@ export async function readGitContext(filePath) {
     const doneAt = content.match(GIT_CTX_RE.doneAt)?.[1];
     const mergeRequestUrl = content.match(GIT_CTX_RE.mergeRequestUrl)?.[1]?.trim();
     const pushedAt = content.match(GIT_CTX_RE.pushedAt)?.[1];
+    const lastReshipAt = content.match(GIT_CTX_RE.lastReshipAt)?.[1];
+    const reshipCountRaw = content.match(GIT_CTX_RE.reshipCount)?.[1];
+    const previousMergeRequestUrls = parsePreviousMergeRequestUrls(content);
     const ctx = { baseBranch, baseCommit, taskBranch, startedAt };
     if (typeof doneAt === "string" && doneAt.length > 0)
         ctx.doneAt = doneAt;
     if (typeof mergeRequestUrl === "string" && mergeRequestUrl.length > 0) {
         ctx.mergeRequestUrl = mergeRequestUrl;
     }
+    if (previousMergeRequestUrls.length > 0) {
+        ctx.previousMergeRequestUrls = previousMergeRequestUrls;
+    }
     if (typeof pushedAt === "string" && pushedAt.length > 0)
         ctx.pushedAt = pushedAt;
+    if (typeof lastReshipAt === "string" && lastReshipAt.length > 0) {
+        ctx.lastReshipAt = lastReshipAt;
+    }
+    if (typeof reshipCountRaw === "string") {
+        const n = Number.parseInt(reshipCountRaw, 10);
+        if (Number.isFinite(n) && n > 0)
+            ctx.reshipCount = n;
+    }
     return ctx;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodtek/vibeops",
-  "version": "2.1.0",
+  "version": "2.1.1",
   "description": "Minimal CLI rails for Cursor-based TASK-driven vibe coding.",
   "type": "module",
   "author": "VibeOps contributors",

package/templates/clients/claude/CLAUDE.md

@@ -2,5 +2,5 @@
 
 - Work from `docs/tasks/TASK-NNN-*.md` only.
 - One TASK at a time.
-- Fill **Result** and **Test Result** before telling the human to run `vibeops task ship TASK-NNN`.
-- Do not merge to integration or main unless the human runs `vibeops task merge` / `task release`.
+- Fill **Result** and **Test Result** before telling the human to run `vibeops task ship TASK-NNN` (or `task reship` for Shipped follow-up).
+- Do not merge to integration or main unless the human runs `vibeops task merge` / `task sync` / `task release`.

package/templates/clients/cursor/.cursor/rules/02-git-safety.mdc

@@ -8,4 +8,4 @@ alwaysApply: true
 - Use branch pattern `task/*` from `vibeops task add`.
 - Include TASK id in commits: `feat(task-nnn): …`.
 - No force-push to shared branches.
-- Run `vibeops task ship`, `task merge`, `task sync` when the human asks — do not merge locally in the IDE unless requested.
+- Run `vibeops task ship`, `task reship`, `task merge`, `task sync` when the human asks — do not merge locally in the IDE unless requested.

package/templates/clients/cursor/.cursor/rules/03-docs-before-ship.mdc

@@ -5,7 +5,7 @@ alwaysApply: true
 
 # Docs before task ship
 
-Before `vibeops task ship`:
+Before `vibeops task ship` or `vibeops task reship`:
 
 1. Fill **Result** and **Test Result** in the TASK file (paths, commands, outcomes — facts only).
 2. If architecture or decisions changed, note them in the TASK; `task ship` can update `docs/project/*` via LLM.

package/templates/core/AGENTS.md

@@ -9,18 +9,33 @@ vibeops task add
 # Plan / build in your agent (@docs/tasks/TASK-NNN-*.md)
 
 vibeops task ship
+vibeops task merge          # CLI or host UI
+vibeops task sync           # optional — branch cleanup only
+
+# Same TASK follow-up (after merge):
+vibeops task reship TASK-NNN
 vibeops task merge
-vibeops task sync
 ```
 
 Optional release to production: `vibeops task release`.
 
+## TASK status (markdown)
+
+Only two values in `## Status`:
+
+| Status | Meaning |
+|--------|---------|
+| **In Progress** | Active slice (`task add`) |
+| **Shipped** | Submitted (`task ship` or `task reship`) |
+
+Merge and sync do **not** change the TASK file.
+
 ```bash
-vibeops llm connect   # optional — task add / task ship
+vibeops llm connect   # optional — task add / ship / reship
 ```
 
 ## Rules
 
-- One TASK at a time; scope from `docs/tasks/TASK-NNN-*.md`.
-- Fill **Result** and **Test Result** before `vibeops task ship`.
-- Agents do not merge or sync unless the human asks.
+- One **In Progress** TASK at a time; **Shipped** does not block `task add`.
+- Fill **Result** and **Test Result** before `vibeops task ship` (or before `task reship` for follow-ups).
+- Agents do not run `task merge`, `task sync`, or `task reship` unless the human asks.

package/templates/core/docs/project/06-decisions.md

@@ -5,5 +5,5 @@
 ## D-001 · VibeOps workflow
 
 - **Date:** {{CREATED_AT}}
-- **Decision:** TASK-driven development with `vibeops task add` / `task ship` / `merge` / `sync` and Cursor for plan/build.
+- **Decision:** TASK-driven development with `vibeops task add` / `task ship` / `task reship` / `merge` / `sync` and Cursor for plan/build. TASK status: **In Progress** → **Shipped** only.
 - **Why:** Git `docs/tasks` beats chat as source of truth.

package/templates/core/docs/tasks/TASK-000-template.md

@@ -2,7 +2,7 @@
 
 ## Status
 
-Planned
+In Progress
 
 ## Goal
 

package/templates/skills-shared/implement-task/SKILL.md

@@ -8,6 +8,6 @@ description: Implement the current VibeOps TASK file in the repo.
 1. Read the full `docs/tasks/TASK-NNN-*.md` (Scope, Acceptance Criteria, Test Plan).
 2. Search the codebase before adding new patterns.
 3. Implement only within the TASK scope.
-4. Do not run `vibeops task ship`, `merge`, or `sync` — the human runs the CLI lifecycle.
+4. Do not run `vibeops task ship`, `reship`, `merge`, or `sync` — the human runs the CLI lifecycle.
 
-When implementation is ready, tell the human to run `vibeops task ship TASK-NNN`.
+When implementation is ready, tell the human to run `vibeops task ship TASK-NNN`. For a **Shipped** follow-up after merge, use `vibeops task reship TASK-NNN`.