@goodtek/vibeops 2.0.0 → 2.1.0

package/CHANGELOG.md

@@ -4,6 +4,13 @@ All notable changes to VibeOps are documented here.
 
 ## Unreleased
 
+### 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 +25,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,9 @@ 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 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`) |
@@ -62,7 +62,7 @@ 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)
 
@@ -101,9 +101,9 @@ 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 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/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,8 @@ async function buildReport(cwd) {
         testFilled,
         onTaskBranch,
         hasMergeRequest: typeof mergeRequestUrl === "string" && mergeRequestUrl.length > 0,
+        mergeRequestMerged,
+        needsSync,
     });
     const llm = isVibeopsProject ? await buildLlmStatusReport(cwd) : null;
     return {
@@ -105,7 +112,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-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/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.`;

package/dist/lib/task-context.js

@@ -1,20 +1,18 @@
 import { relative } from "node:path";
 import { gitBranchExists, readGitInfo } from "./git.js";
+import { isMergeRequestMerged, taskNeedsSync } from "./task-effective-status.js";
 import { readGitContext } from "./task.js";
 import { isOnTaskBranch, loadActionableTasks, pickActiveTask, pickInProgressTask, } from "./task.js";
-/** TASK that blocks `task add` — in progress, in review, or open on current task branch. */
+/** Only **In Progress** blocks the next `task add`. */
 export async function findBlockingTask(paths, cwd) {
     const tasks = await loadActionableTasks(paths.docsTasks);
     const inProgress = pickInProgressTask(tasks);
     if (inProgress !== null)
         return inProgress;
-    const review = tasks.find((t) => t.status === "review");
-    if (review !== undefined)
-        return review;
     const git = await readGitInfo(cwd);
     if (git.isRepo && typeof git.branch === "string" && git.branch.startsWith("task/")) {
         for (const t of tasks) {
-            if (t.status === "done")
+            if (t.status !== "in_progress")
                 continue;
             const ctx = await readGitContext(t.filePath);
             if (isOnTaskBranch(git.branch, ctx))
@@ -24,7 +22,17 @@ export async function findBlockingTask(paths, cwd) {
     return null;
 }
 export async function pickFocusTask(paths, cwd) {
-    return pickActiveTask(paths.docsTasks, cwd);
+    const active = await pickActiveTask(paths.docsTasks, cwd);
+    if (active !== null)
+        return active;
+    const shipped = (await loadActionableTasks(paths.docsTasks))
+        .filter((t) => t.status === "shipped")
+        .sort((a, b) => {
+        const na = Number.parseInt(/^TASK-(\d+)$/i.exec(a.id)?.[1] ?? "0", 10);
+        const nb = Number.parseInt(/^TASK-(\d+)$/i.exec(b.id)?.[1] ?? "0", 10);
+        return nb - na;
+    });
+    return shipped[0] ?? null;
 }
 export function relPath(cwd, filePath) {
     const r = relative(cwd, filePath).replace(/\\/g, "/");
@@ -35,11 +43,12 @@ export function computeNextHint(input) {
         return "init";
     if (input.focus === null)
         return "task-add";
-    if (input.focus.status === "done") {
-        return input.onTaskBranch === true ? "task-sync" : "task-add";
-    }
-    if (input.focus.status === "review") {
-        return input.hasMergeRequest ? "task-merge" : "task-ship";
+    if (input.focus.status === "shipped") {
+        if (input.needsSync)
+            return "task-sync";
+        if (input.hasMergeRequest && !input.mergeRequestMerged)
+            return "task-merge";
+        return "task-add";
     }
     if (!input.resultFilled || !input.testFilled) {
         return input.onTaskBranch === true ? "cursor-implement" : "cursor-plan";
@@ -56,12 +65,12 @@ export function hintToText(hint, cwd, task) {
             return task ? `Run \`vibeops task ship ${task.id}\`.` : "Run `vibeops task ship`.";
         case "task-merge":
             return task
-                ? `Run \`vibeops task merge ${task.id}\`, then task sync.`
-                : "Run `vibeops task merge` after the MR is ready.";
+                ? `Merge the MR (UI or \`vibeops task merge ${task.id}\`), then optional task sync.`
+                : "Merge the MR on the host or with `vibeops task merge`.";
         case "task-sync":
             return task
-                ? `MR merged? Run \`vibeops task sync ${task.id}\`, then task add.`
-                : "Run `vibeops task sync` after merging the MR.";
+                ? `Run \`vibeops task sync ${task.id}\` to delete task branches, then task add.`
+                : "Run `vibeops task sync` to delete task branches after merge.";
         case "cursor-plan":
             return task
                 ? `In Cursor Ask: @${relPath(cwd, task.filePath)} — refine Scope / AC.`
@@ -81,3 +90,4 @@ export async function taskBranchExistsFor(cwd, task) {
         return false;
     return gitBranchExists(cwd, ctx.taskBranch);
 }
+export { isMergeRequestMerged, taskNeedsSync };

package/dist/lib/task-effective-status.js

@@ -0,0 +1,62 @@
+import { GitConfigError, requireGitConfig } from "./git-config.js";
+import { detectGitHost } from "./git-host.js";
+import { gitBranchExists, gitRemoteBranchExists, gitRemoteUrl, } from "./git.js";
+import { getMergeRequestState, probeMergeRequestCli } from "./pr-create.js";
+import { readGitContext } from "./task.js";
+/** MR state for a TASK file, or `null` when there is no MR URL or host CLI is unavailable. */
+export async function getMergeRequestStateForTask(cwd, taskFile) {
+    const ctx = await readGitContext(taskFile);
+    const url = ctx?.mergeRequestUrl?.trim();
+    if (url === undefined || url.length === 0)
+        return null;
+    let host;
+    try {
+        const gitCfg = await requireGitConfig(cwd);
+        const remoteUrl = await gitRemoteUrl(cwd, gitCfg.remote);
+        host =
+            remoteUrl !== null && detectGitHost(remoteUrl) !== null
+                ? detectGitHost(remoteUrl)
+                : gitCfg.host;
+    }
+    catch (e) {
+        if (e instanceof GitConfigError)
+            return null;
+        throw e;
+    }
+    if (!(await probeMergeRequestCli(host)))
+        return null;
+    return getMergeRequestState(cwd, host, url);
+}
+export async function isMergeRequestMerged(cwd, task) {
+    if (task.status !== "shipped")
+        return false;
+    const state = await getMergeRequestStateForTask(cwd, task.filePath);
+    return state === "merged";
+}
+/**
+ * After ship: optional `task sync` when MR is merged (or no MR) but `task/*` still exists.
+ */
+export async function taskNeedsSync(cwd, task) {
+    if (task.status !== "shipped")
+        return false;
+    const ctx = await readGitContext(task.filePath);
+    if (ctx === null)
+        return false;
+    const mrUrl = ctx.mergeRequestUrl?.trim();
+    if (mrUrl !== undefined && mrUrl.length > 0) {
+        const state = await getMergeRequestStateForTask(cwd, task.filePath);
+        if (state !== "merged")
+            return false;
+    }
+    if (await gitBranchExists(cwd, ctx.taskBranch))
+        return true;
+    try {
+        const gitCfg = await requireGitConfig(cwd);
+        return gitRemoteBranchExists(cwd, gitCfg.remote, ctx.taskBranch);
+    }
+    catch (e) {
+        if (e instanceof GitConfigError)
+            return false;
+        throw e;
+    }
+}

package/dist/lib/task-lifecycle-target.js

@@ -1,5 +1,5 @@
 import { readGitInfo } from "./git.js";
-import { isOnTaskBranch, loadActionableTasks, pickLatestReviewTask, readGitContext, } from "./task.js";
+import { isOnTaskBranch, loadActionableTasks, pickLatestShippedTask, readGitContext, } from "./task.js";
 import { resolveTask } from "./resolve-task.js";
 /** Resolve TASK + task branch for ship / merge / sync. */
 export async function resolveLifecycleTarget(paths, cwd, taskRef) {
@@ -27,15 +27,15 @@ export async function resolveLifecycleTarget(paths, cwd, taskRef) {
             }
         }
     }
-    const review = pickLatestReviewTask(await loadActionableTasks(paths.docsTasks));
-    if (review === null)
+    const shipped = pickLatestShippedTask(await loadActionableTasks(paths.docsTasks));
+    if (shipped === null)
         return null;
-    const ctx = await readGitContext(review.filePath);
+    const ctx = await readGitContext(shipped.filePath);
     if (ctx === null)
         return null;
     return {
-        taskId: review.id,
+        taskId: shipped.id,
         taskBranch: ctx.taskBranch,
-        taskFile: review.filePath,
+        taskFile: shipped.filePath,
     };
 }

package/dist/lib/task-scaffold.js

@@ -28,7 +28,7 @@ export function buildMinimalTaskMarkdown(draft) {
 
 ## Status
 
-${statusDisplay("planned")}
+${statusDisplay("in_progress")}
 
 ## Goal
 

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

@@ -31,7 +31,7 @@ export async function llmCompleteTaskShip(params) {
     const messages = [
         {
             role: "system",
-            content: `You ship a VibeOps TASK for review. Reply with JSON only:
+            content: `You ship a VibeOps TASK (Status → Shipped). Reply with JSON only:
 {
   "result": "markdown for TASK Result section — facts, paths, commands",
   "testResult": "markdown for Test Result — commands and outcomes",
@@ -91,7 +91,7 @@ Be factual. Do not invent files not in the diff.`,
                 : null,
             logLine: typeof parsed.logLine === "string" && parsed.logLine.trim().length > 0
                 ? parsed.logLine.trim()
-                : `${params.taskId} shipped for review.`,
+                : `${params.taskId} shipped.`,
             provider,
         };
     }
@@ -147,7 +147,7 @@ export async function fallbackResultSections(cwd, taskId, taskFile) {
     const body = await readText(taskFile);
     const goal = readSection(body, "Goal").slice(0, 200);
     const result = [
-        `Shipped ${taskId} for review.`,
+        `Shipped ${taskId}.`,
         goal.length > 0 ? `Goal: ${goal}` : "",
         names.length > 0 ? `Paths: ${names.slice(0, 15).join(", ")}` : "",
     ]

package/dist/lib/task-start.js

@@ -81,7 +81,7 @@ export async function startTaskBranch(opts) {
     log.info(`  ${dim("task branch")}  ${cyan(taskBranch)}`);
     if (branchExists) {
         await gitCheckout(cwd, taskBranch);
-        if (meta.status === "planned") {
+        if (meta.status !== "shipped") {
             await updateInlineStatus(taskFile, "in_progress");
         }
         if (existingCtx === null) {

package/dist/lib/task.js

@@ -3,33 +3,31 @@ import { basename, extname, join } from "node:path";
 import matter from "gray-matter";
 import { isDirectory, readText, writeText } from "./filesystem.js";
 import { readGitInfo } from "./git.js";
-const KNOWN_STATUSES = new Set([
-    "planned",
-    "in_progress",
+const SHIPPED_ALIASES = new Set([
     "review",
-    "blocked",
+    "merged",
     "done",
+    "shipped",
+    "ready_for_review",
 ]);
 export function normalizeStatus(value) {
     if (typeof value === "string") {
         const s = value.toLowerCase().replace(/\s+/g, "_");
-        if (KNOWN_STATUSES.has(s))
-            return s;
+        if (s === "in_progress" || s === "inprogress")
+            return "in_progress";
+        if (SHIPPED_ALIASES.has(s))
+            return "shipped";
+        if (s === "planned" || s === "blocked")
+            return "in_progress";
     }
-    return "planned";
+    return "in_progress";
 }
 export function statusDisplay(status) {
     switch (status) {
-        case "planned":
-            return "Planned";
         case "in_progress":
             return "In Progress";
-        case "review":
-            return "Review";
-        case "blocked":
-            return "Blocked";
-        case "done":
-            return "Done";
+        case "shipped":
+            return "Shipped";
     }
 }
 function extractIdFromFilename(file) {
@@ -89,7 +87,7 @@ export async function readTaskFile(filePath) {
     const title = titleFromFm ?? extractTitleFromBody(body);
     const status = data["status"] !== undefined
         ? normalizeStatus(data["status"])
-        : (extractInlineStatus(body) ?? "planned");
+        : (extractInlineStatus(body) ?? "in_progress");
     const mvpPhaseFromFm = typeof data["mvpPhase"] === "string" ? data["mvpPhase"] : undefined;
     const mvpPhase = mvpPhaseFromFm ?? extractInlineMvpPhase(body);
     const priority = typeof data["priority"] === "string" ? data["priority"] : undefined;
@@ -117,11 +115,8 @@ export async function scanTasks(tasksDir) {
 export function countTasks(tasks) {
     const counts = {
         total: tasks.length,
-        planned: 0,
         in_progress: 0,
-        review: 0,
-        blocked: 0,
-        done: 0,
+        shipped: 0,
     };
     for (const t of tasks)
         counts[t.status]++;
@@ -131,14 +126,7 @@ export function pickInProgressTask(tasks) {
     return tasks.find((t) => t.status === "in_progress") ?? null;
 }
 export function pickNextTask(tasks) {
-    const inProgress = pickInProgressTask(tasks);
-    if (inProgress)
-        return inProgress;
-    const review = tasks.find((t) => t.status === "review");
-    if (review)
-        return review;
-    const planned = tasks.filter((t) => t.status === "planned");
-    return planned[0] ?? null;
+    return pickInProgressTask(tasks);
 }
 const TEMPLATE_TASK_ID = "TASK-000";
 export function filterActionableTasks(tasks) {
@@ -148,19 +136,12 @@ function taskSortKey(id) {
     const m = /^TASK-(\d+)$/i.exec(id.trim());
     return m ? Number.parseInt(m[1], 10) : 0;
 }
-/** Latest finished TASK by numeric id (TASK-mvp sorts after numbered tasks). */
-export function pickLatestDoneTask(tasks) {
-    const done = filterActionableTasks(tasks).filter((t) => t.status === "done");
-    if (done.length === 0)
+/** Latest **Shipped** TASK (for merge / sync targeting). */
+export function pickLatestShippedTask(tasks) {
+    const shipped = filterActionableTasks(tasks).filter((t) => t.status === "shipped");
+    if (shipped.length === 0)
         return null;
-    return [...done].sort((a, b) => taskSortKey(b.id) - taskSortKey(a.id))[0];
-}
-/** Latest TASK in Review (awaiting merge / sync). */
-export function pickLatestReviewTask(tasks) {
-    const review = filterActionableTasks(tasks).filter((t) => t.status === "review");
-    if (review.length === 0)
-        return null;
-    return [...review].sort((a, b) => taskSortKey(b.id) - taskSortKey(a.id))[0];
+    return [...shipped].sort((a, b) => taskSortKey(b.id) - taskSortKey(a.id))[0];
 }
 export async function loadActionableTasks(tasksDir) {
     return filterActionableTasks(await scanTasks(tasksDir));
@@ -185,7 +166,7 @@ export async function pickActiveTask(tasksDir, cwd) {
                 return t;
         }
     }
-    return pickNextTask(actionable);
+    return pickNextTask(actionable.filter((t) => t.status === "in_progress"));
 }
 export async function findTaskFile(tasksDir, taskId) {
     const all = await scanTasks(tasksDir);

package/package.json

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

package/templates/core/docs/project/05-current-state.md

@@ -1,6 +1,6 @@
 # Current state
 
-> Facts only. Updated by `vibeops task ship` / humans; stage changes on `task sync`.
+> Facts only. Updated by `vibeops task ship` / humans after merge (not by `task sync`).
 
 ## Stage