@goodtek/vibeops 2.0.0 → 2.1.1

package/CHANGELOG.md

@@ -4,6 +4,26 @@ 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.
+- **`task sync`**: Git cleanup only (integration pull, delete `task/*` branches).
+- **`task add`**: blocks only another **In Progress** TASK (not **Shipped**).
+- Legacy statuses (Review, Done, Merged, Planned, …) normalize to **In Progress** or **Shipped** when read.
+
 ## 2.0.0 - 2026-06-03
 
 ### Breaking
@@ -18,7 +38,7 @@ All notable changes to VibeOps are documented here.
 
 ### Changed
 
-- **`task ship`** replaces `task done`: Done status and `doneAt` are set on **`task sync`** on the integration branch, not at ship time.
+- **`task ship`** replaces `task done`: Review on the task branch at ship; **Done** is derived from merged MR (see Unreleased — sync no longer writes TASK md).
 - **`status`** next hints: ship → merge → sync.
 - Templates and Cursor rules reference ship / merge / sync (rule file `03-docs-before-ship.mdc`).
 

package/README.md

@@ -13,9 +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 ship` | LLM summary, commit, push, open MR/PR (Status → Review) |
+| `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: update integration branch, mark Done, delete task branch |
+| `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 status` | Briefing: TASK, Git, LLM, clients |
 | `vibeops llm` | Connect LLM providers (`connect` · `status` · `use`) |
@@ -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
 ```
@@ -62,11 +66,11 @@ Occasionally (GitFlow release to production):
 vibeops task release
 ```
 
-If a TASK is **In Progress** or **Review**, `task add` exits with a guide.
+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)
 
-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`
@@ -101,9 +106,10 @@ 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 **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 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).
 - No force-push to shared branches.
 

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

@@ -8,7 +8,8 @@ import { bold, cyan, dim, green, log, yellow } from "../lib/logger.js";
 import { projectPaths } from "../lib/paths.js";
 import { VERSION } from "../version.js";
 import { computeNextHint, hintToText, listInProgressTasks, pickFocusTask, relPath, taskBranchExistsFor, } from "../lib/task-context.js";
-import { countTasks, hasNonEmptySection, isOnTaskBranch, loadActionableTasks, readGitContext, statusDisplay } from "../lib/task.js";
+import { isMergeRequestMerged, taskNeedsSync } from "../lib/task-effective-status.js";
+import { countTasks, hasNonEmptySection, isOnTaskBranch, loadActionableTasks, readGitContext, statusDisplay, } from "../lib/task.js";
 import { summarizeGoal } from "../lib/task-summary.js";
 async function buildReport(cwd) {
     const paths = projectPaths(cwd);
@@ -32,6 +33,8 @@ async function buildReport(cwd) {
     let branchExists = null;
     let goalExcerpt = "";
     let mergeRequestUrl = null;
+    let mergeRequestMerged = false;
+    let needsSync = false;
     if (focus !== null) {
         const body = await readText(focus.filePath);
         goalExcerpt = summarizeGoal(body);
@@ -42,6 +45,8 @@ async function buildReport(cwd) {
         mergeRequestUrl = ctx?.mergeRequestUrl ?? null;
         onTaskBranch = isOnTaskBranch(git.branch, ctx);
         branchExists = await taskBranchExistsFor(cwd, focus);
+        mergeRequestMerged = await isMergeRequestMerged(cwd, focus);
+        needsSync = await taskNeedsSync(cwd, focus);
         focusBlock = {
             id: focus.id,
             title: focus.title,
@@ -63,6 +68,9 @@ async function buildReport(cwd) {
         testFilled,
         onTaskBranch,
         hasMergeRequest: typeof mergeRequestUrl === "string" && mergeRequestUrl.length > 0,
+        mergeRequestMerged,
+        needsSync,
+        hasLocalChanges: git.dirty === true,
     });
     const llm = isVibeopsProject ? await buildLlmStatusReport(cwd) : null;
     return {
@@ -105,7 +113,7 @@ function printHuman(report) {
     }
     if (report.counts) {
         const c = report.counts;
-        log.info(`  ${dim("Tasks")}    ${c.total} total · ${cyan(String(c.in_progress))} in progress · ${c.done} done`);
+        log.info(`  ${dim("Tasks")}    ${c.total} total · ${cyan(String(c.in_progress))} in progress · ${c.shipped} shipped`);
     }
     if (report.inProgress.length > 1) {
         log.blank();

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 sync ${blocking.id}`)} (after ship + merge)`);
+        log.info(`Finish it first: ${cyan(`vibeops task ship ${blocking.id}`)}.`);
         log.info(`Then run ${cyan("vibeops task add")} again.`);
         process.exitCode = 1;
         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/commands/task-ship.js

@@ -11,30 +11,30 @@ import { finishTaskWithPullRequest } from "../lib/task-push-pr.js";
 import { hasNonEmptySection, parseTaskFilename, readGitContext, readTaskFile, updateInlineStatus, } from "../lib/task.js";
 async function commitShipMetadataAndPush(opts) {
     if (opts.dryRun) {
-        log.info(dim("  would set Status → Review"));
+        log.info(dim("  would set Status → Shipped"));
         log.info(dim("  would commit ship metadata"));
         if (opts.push !== null) {
-            log.info(dim(`  would git push ${opts.push.remote} ${opts.push.branch} (review metadata)`));
+            log.info(dim(`  would git push ${opts.push.remote} ${opts.push.branch} (ship metadata)`));
         }
         return true;
     }
-    await updateInlineStatus(opts.taskFile, "review");
-    log.ok("Status → Review");
-    const committed = await commitDirtyWorkingTree(opts.cwd, docsCommitMessageFor(opts.taskId, "ready for review"), false);
+    await updateInlineStatus(opts.taskFile, "shipped");
+    log.ok("Status → Shipped");
+    const committed = await commitDirtyWorkingTree(opts.cwd, docsCommitMessageFor(opts.taskId, "mark shipped"), false);
     if (!committed) {
-        log.warn("No file changes for review metadata commit — check TASK Status on the remote branch.");
+        log.warn("No file changes for ship metadata commit — check TASK Status on the remote branch.");
         return true;
     }
     if (opts.push === null)
         return true;
     try {
         await pushBranch(opts.cwd, opts.push.remote, opts.push.branch, false);
-        log.ok(`Pushed review metadata → ${opts.push.remote}/${opts.push.branch}`);
+        log.ok(`Pushed ship metadata → ${opts.push.remote}/${opts.push.branch}`);
         return true;
     }
     catch (e) {
         const msg = e instanceof Error ? e.message : String(e);
-        log.error(`Review metadata push failed: ${msg}`);
+        log.error(`Ship metadata push failed: ${msg}`);
         log.info(dim(`Fix auth/remote, then: git push ${opts.push.remote} ${opts.push.branch}`));
         return false;
     }
@@ -105,7 +105,7 @@ export async function taskShipCommand(taskRef, options = {}) {
             log.info("  · LLM fill Result / Test Result + patch docs/project/*");
         }
         log.info("  · commit implementation, push task branch, open MR/PR (unless --no-pr)");
-        log.info("  · Status → Review; commit metadata; push again");
+        log.info("  · Status → Shipped; commit metadata; push again");
         await finishTaskWithPullRequest({
             cwd,
             taskFile,
@@ -166,7 +166,7 @@ export async function taskShipCommand(taskRef, options = {}) {
         push: pushTarget,
     });
     if (!shipped) {
-        log.error("Review metadata push failed — fix manually, then run task merge.");
+        log.error("Ship metadata push failed — fix manually, then merge the MR.");
         process.exitCode = 1;
         return;
     }

package/dist/commands/task-sync.js

@@ -3,13 +3,13 @@ import { GitConfigError, requireGitConfig } from "../lib/git-config.js";
 import { detectGitHost, mergeRequestLabel } from "../lib/git-host.js";
 import { gitBranchExists, gitDeleteBranch, gitDeleteRemoteBranch, gitFetchRemote, gitPullFastForwardOnly, gitRemoteBranchExists, gitRemoteUrl, gitSwitchToBranch, readGitInfo, } from "../lib/git.js";
 import { bold, cyan, dim, log, yellow } from "../lib/logger.js";
-import { getMergeRequestState, probeMergeRequestCli } from "../lib/pr-create.js";
+import { probeMergeRequestCli } from "../lib/pr-create.js";
 import { projectPaths } from "../lib/paths.js";
 import { taskNotFoundMessage } from "../lib/resolve-task.js";
 import { relPath } from "../lib/task-context.js";
-import { commitDirtyWorkingTree, docsCommitMessageFor, pushBranch, } from "../lib/task-git-commit.js";
+import { getMergeRequestStateForTask, isMergeRequestMerged, } from "../lib/task-effective-status.js";
 import { resolveLifecycleTarget } from "../lib/task-lifecycle-target.js";
-import { markGitContextDone, readGitContext, readTaskFile, updateInlineStatus, } from "../lib/task.js";
+import { readGitContext, readTaskFile } from "../lib/task.js";
 function isProtectedBranch(name, integration, production) {
     return name === integration || name === production || name === "main" || name === "master";
 }
@@ -52,15 +52,16 @@ export async function taskSyncCommand(taskRef, options = {}) {
     log.info(`  ${dim("task branch")}  ${cyan(taskBranch)}`);
     log.info(`  ${dim("integration")}  ${integrationBranch}`);
     log.info(`  ${dim("file")}          ${relPath(cwd, taskFile)}`);
+    log.info(`  ${dim("note")}        ${dim("Git cleanup only — TASK md stays Shipped")}`);
     log.blank();
     const meta = await readTaskFile(taskFile);
     if (ctx?.mergeRequestUrl && !dryRun) {
-        const remoteUrl = await gitRemoteUrl(cwd, remote);
-        const host = remoteUrl !== null && detectGitHost(remoteUrl) !== null
-            ? detectGitHost(remoteUrl)
-            : gitCfg.host;
-        if (await probeMergeRequestCli(host)) {
-            const state = await getMergeRequestState(cwd, host, ctx.mergeRequestUrl);
+        const state = await getMergeRequestStateForTask(cwd, taskFile);
+        if (state !== null) {
+            const remoteUrl = await gitRemoteUrl(cwd, remote);
+            const host = remoteUrl !== null && detectGitHost(remoteUrl) !== null
+                ? detectGitHost(remoteUrl)
+                : gitCfg.host;
             const label = mergeRequestLabel(host);
             if (state === "open") {
                 log.warn(`${yellow(label)} still open — merge with task merge or the host UI before sync.`);
@@ -69,22 +70,23 @@ export async function taskSyncCommand(taskRef, options = {}) {
                 log.ok(`${label} merged.`);
             }
         }
+        else if (await probeMergeRequestCli(gitCfg.host)) {
+            log.warn("Could not read MR state — continuing with branch cleanup.");
+        }
     }
-    else if (meta.status === "review") {
-        log.warn(`${yellow("Status")} is Review — merge the MR first, then rerun task sync.`);
+    else if (meta.status === "shipped" && !(await isMergeRequestMerged(cwd, meta))) {
+        log.warn(`${yellow("MR")} not merged yet — merge on the host or \`task merge\`, then rerun task sync.`);
     }
     if (dryRun) {
         log.info(bold("dry-run — would:"));
         log.info(`  · git fetch ${remote} --prune`);
         log.info(`  · git switch ${integrationBranch}`);
         log.info(`  · git pull --ff-only ${remote} ${integrationBranch}`);
-        if (meta.status !== "done") {
-            log.info("  · Status → Done on integration branch; commit; push");
-        }
         log.info(`  · git branch ${options.force === true ? "-D" : "-d"} ${taskBranch}`);
         if (options.noRemoteDelete !== true) {
             log.info(`  · git push ${remote} --delete ${taskBranch} (if exists)`);
         }
+        log.info(dim("  · no edits to docs/tasks/*.md"));
         log.blank();
         log.info(`Next: ${cyan("vibeops task add")}`);
         return;
@@ -128,23 +130,6 @@ export async function taskSyncCommand(taskRef, options = {}) {
     else {
         log.warn(`No ${remote}/${integrationBranch} — skipped pull.`);
     }
-    const metaOnIntegration = await readTaskFile(taskFile);
-    if (metaOnIntegration.status !== "done") {
-        await updateInlineStatus(taskFile, "done");
-        await markGitContextDone(taskFile);
-        log.ok("Status → Done");
-        const committed = await commitDirtyWorkingTree(cwd, docsCommitMessageFor(taskId, "mark done"), false);
-        if (committed) {
-            try {
-                await pushBranch(cwd, remote, integrationBranch, false);
-                log.ok(`Pushed done metadata → ${remote}/${integrationBranch}`);
-            }
-            catch (e) {
-                const msg = e instanceof Error ? e.message : String(e);
-                log.warn(`Could not push done metadata: ${msg}`);
-            }
-        }
-    }
     if (await gitBranchExists(cwd, taskBranch)) {
         try {
             await gitDeleteBranch(cwd, taskBranch, { force: options.force === true });

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/resolve-task.js

@@ -21,7 +21,7 @@ export async function resolveTask(paths, cwd, taskRef) {
         return { taskId: inProgress.id, taskFile: inProgress.filePath };
     }
     const onBranch = await pickActiveTask(paths.docsTasks, cwd);
-    if (onBranch !== null && onBranch.status !== "done") {
+    if (onBranch !== null && onBranch.status === "in_progress") {
         return { taskId: onBranch.id, taskFile: onBranch.filePath };
     }
     return null;

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

@@ -40,7 +40,7 @@ function systemPrompt() {
 }
 
 markdown must include sections: Status, Goal, Scope, Out of Scope, Acceptance Criteria, Test Plan, Git Context, Result, Test Result.
-Status body: ${statusDisplay("planned")}
+Status body: ${statusDisplay("in_progress")}
 Result and Test Result: (not yet)
 Git Context: (populated by vibeops task add)
 Use the exact TASK id given in the user message for the # heading.`;