@goodtek/vibeops 1.1.2 → 2.1.0

package/dist/commands/{task-done.js → task-ship.js}

@@ -1,76 +1,45 @@
 import { resolve } from "node:path";
 import { readText } from "../lib/filesystem.js";
+import { requireGitConfig } from "../lib/git-config.js";
 import { bold, cyan, dim, green, log, yellow } from "../lib/logger.js";
 import { projectPaths } from "../lib/paths.js";
 import { resolveTask, taskNotFoundMessage } from "../lib/resolve-task.js";
-import { applyTaskDoneMemory, fallbackResultSections, llmCompleteTaskDone, writeTaskResultSections, } from "../lib/task-done-llm.js";
 import { relPath } from "../lib/task-context.js";
-import { requireGitConfig } from "../lib/git-config.js";
-import { gitAddPaths, gitPush, listWorkingTreeRelPaths, partitionPathsForAutoCommit, readGitInfo, runGit, } from "../lib/git.js";
-import { hasNonEmptySection, markGitContextDone, parseTaskFilename, readGitContext, readTaskFile, updateInlineStatus, } from "../lib/task.js";
+import { commitDirtyWorkingTree, docsCommitMessageFor, featCommitMessageFor, pushBranch, } from "../lib/task-git-commit.js";
+import { applyTaskShipMemory, fallbackResultSections, llmCompleteTaskShip, writeTaskResultSections, } from "../lib/task-ship-llm.js";
 import { finishTaskWithPullRequest } from "../lib/task-push-pr.js";
-function commitMessageFor(taskId, title) {
-    const slug = title.replace(/^TASK-\d+\s*[:\-]\s*/i, "").trim() || taskId;
-    return `feat(${taskId.toLowerCase()}): ${slug}`;
-}
-function closureCommitMessageFor(taskId) {
-    return `docs(${taskId.toLowerCase()}): close task metadata`;
-}
-async function tryCommitDirty(cwd, message, dryRun) {
-    const git = await readGitInfo(cwd);
-    if (!git.isRepo || git.dirty !== true)
-        return false;
-    const { committable, excluded } = partitionPathsForAutoCommit(await listWorkingTreeRelPaths(cwd), { unmerged: [] });
-    if (committable.length === 0)
-        return false;
-    if (excluded.length > 0) {
-        log.warn(`Skipping ${excluded.length} build artifact path(s) from auto-commit.`);
-    }
-    if (dryRun) {
-        log.info(dim(`  would commit ${committable.length} path(s)`));
-        return true;
-    }
-    await gitAddPaths(cwd, committable);
-    await runGit(cwd, ["commit", "-q", "-m", message]);
-    log.ok(`Committed: ${message}`);
-    return true;
-}
-/**
- * After push/MR: write Status Done + Git Context closure, commit, push so the remote
- * branch matches local TASK metadata (canonical two-phase close).
- */
-async function commitClosureMetadataAndPush(opts) {
+import { hasNonEmptySection, parseTaskFilename, readGitContext, readTaskFile, updateInlineStatus, } from "../lib/task.js";
+async function commitShipMetadataAndPush(opts) {
     if (opts.dryRun) {
-        log.info(dim("  would set Status → Done and update Git Context (doneAt)"));
-        log.info(dim("  would commit closure metadata"));
+        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} (closure commit)`));
+            log.info(dim(`  would git push ${opts.push.remote} ${opts.push.branch} (ship metadata)`));
         }
         return true;
     }
-    await updateInlineStatus(opts.taskFile, "done");
-    await markGitContextDone(opts.taskFile);
-    log.ok("Status → Done");
-    const committed = await tryCommitDirty(opts.cwd, closureCommitMessageFor(opts.taskId), 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 closure commit — verify TASK Status and Git Context 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 gitPush(opts.cwd, opts.push.remote, opts.push.branch, false);
-        log.ok(`Pushed closure commit → ${opts.push.remote}/${opts.push.branch}`);
+        await pushBranch(opts.cwd, opts.push.remote, opts.push.branch, false);
+        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(`Closure commit 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;
     }
 }
-export async function taskDoneCommand(taskRef, options = {}) {
+export async function taskShipCommand(taskRef, options = {}) {
     const cwd = resolve(options.cwd ?? process.cwd());
     const paths = projectPaths(cwd);
     const dryRun = options.dryRun === true;
@@ -84,7 +53,7 @@ export async function taskDoneCommand(taskRef, options = {}) {
     const meta = await readTaskFile(taskFile);
     const body = await readText(taskFile);
     const relFile = relPath(cwd, taskFile);
-    log.info(bold(`vibeops task done ${taskId}`));
+    log.info(bold(`vibeops task ship ${taskId}`));
     log.info(`  ${dim("file")}  ${relFile}`);
     log.blank();
     let resultOk = hasNonEmptySection(body, "Result");
@@ -95,7 +64,7 @@ export async function taskDoneCommand(taskRef, options = {}) {
             log.info(dim("  would call LLM and patch docs/project/*"));
         }
         else {
-            const patch = await llmCompleteTaskDone({
+            const patch = await llmCompleteTaskShip({
                 cwd,
                 taskId,
                 taskTitle: meta.title,
@@ -105,7 +74,7 @@ export async function taskDoneCommand(taskRef, options = {}) {
             if (patch !== null) {
                 await writeTaskResultSections(taskFile, patch.result, patch.testResult);
                 log.ok(`Result / Test Result updated (${patch.provider})`);
-                const memory = await applyTaskDoneMemory(cwd, patch);
+                const memory = await applyTaskShipMemory(cwd, patch);
                 for (const p of memory.updated)
                     log.ok(`Updated ${p}`);
                 for (const p of memory.skipped)
@@ -136,7 +105,7 @@ export async function taskDoneCommand(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 → Done; commit closure metadata; push again");
+        log.info("  · Status → Shipped; commit metadata; push again");
         await finishTaskWithPullRequest({
             cwd,
             taskFile,
@@ -144,10 +113,8 @@ export async function taskDoneCommand(taskRef, options = {}) {
             skipPr: options.noPr === true,
         });
         const gitCtxDry = await readGitContext(taskFile);
-        const gitCfgDry = gitCtxDry !== null
-            ? await requireGitConfig(cwd).catch(() => null)
-            : null;
-        await commitClosureMetadataAndPush({
+        const gitCfgDry = gitCtxDry !== null ? await requireGitConfig(cwd).catch(() => null) : null;
+        await commitShipMetadataAndPush({
             cwd,
             taskFile,
             taskId,
@@ -159,8 +126,7 @@ export async function taskDoneCommand(taskRef, options = {}) {
         return;
     }
     const parts = parseTaskFilename(taskFile);
-    const commitMsg = commitMessageFor(parts.id, meta.title);
-    await tryCommitDirty(cwd, commitMsg, false);
+    await commitDirtyWorkingTree(cwd, featCommitMessageFor(parts.id, meta.title), false);
     const gitCtx = await readGitContext(taskFile);
     if (gitCtx !== null) {
         const prResult = await finishTaskWithPullRequest({
@@ -169,13 +135,12 @@ export async function taskDoneCommand(taskRef, options = {}) {
             skipPr: options.noPr === true,
         });
         if (!prResult.ok) {
-            log.error("TASK left In Progress — fix push/MR, then rerun task done.");
+            log.error("TASK left In Progress — fix push/MR, then rerun task ship.");
             process.exitCode = 1;
             return;
         }
         if (prResult.mergeRequestUrl) {
             log.info(`  ${dim("MR/PR")}     ${prResult.mergeRequestUrl}`);
-            log.info(dim("Merge on GitHub/GitLab — CI deploys after merge."));
         }
     }
     else {
@@ -193,18 +158,18 @@ export async function taskDoneCommand(taskRef, options = {}) {
                 log.warn(e.message);
         }
     }
-    const closed = await commitClosureMetadataAndPush({
+    const shipped = await commitShipMetadataAndPush({
         cwd,
         taskFile,
         taskId: parts.id,
         dryRun: false,
         push: pushTarget,
     });
-    if (!closed) {
-        log.error("TASK metadata is Done locally but closure push failed — push manually, then continue.");
+    if (!shipped) {
+        log.error("Ship metadata push failed — fix manually, then merge the MR.");
         process.exitCode = 1;
         return;
     }
     log.blank();
-    log.info(`Next: ${cyan("vibeops task add")} or ${cyan("vibeops status")}`);
+    log.info(`Next: ${cyan("vibeops task merge")} (or merge in the host UI), then ${cyan("vibeops task sync")}`);
 }

package/dist/commands/task-sync.js

@@ -0,0 +1,168 @@
+import { resolve } from "node:path";
+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 { 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 { getMergeRequestStateForTask, isMergeRequestMerged, } from "../lib/task-effective-status.js";
+import { resolveLifecycleTarget } from "../lib/task-lifecycle-target.js";
+import { readGitContext, readTaskFile } from "../lib/task.js";
+function isProtectedBranch(name, integration, production) {
+    return name === integration || name === production || name === "main" || name === "master";
+}
+export async function taskSyncCommand(taskRef, options = {}) {
+    const cwd = resolve(options.cwd ?? process.cwd());
+    const dryRun = options.dryRun === true;
+    const paths = projectPaths(cwd);
+    let gitCfg;
+    try {
+        gitCfg = await requireGitConfig(cwd);
+    }
+    catch (e) {
+        if (e instanceof GitConfigError) {
+            log.error(e.message);
+            process.exitCode = 1;
+            return;
+        }
+        throw e;
+    }
+    const target = await resolveLifecycleTarget(paths, cwd, taskRef);
+    if (target === null) {
+        if (taskRef?.trim()) {
+            log.error(taskNotFoundMessage(taskRef));
+        }
+        else {
+            log.error("No TASK to sync. Pass TASK-NNN, checkout a task/* branch, or run task ship first.");
+        }
+        process.exitCode = 1;
+        return;
+    }
+    const { integrationBranch, productionBranch, remote } = gitCfg;
+    const { taskId, taskBranch, taskFile } = target;
+    const ctx = await readGitContext(taskFile);
+    if (isProtectedBranch(taskBranch, integrationBranch, productionBranch)) {
+        log.error(`Refusing to delete protected branch: ${taskBranch}`);
+        process.exitCode = 1;
+        return;
+    }
+    log.info(bold(`vibeops task sync ${taskId}`));
+    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 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.`);
+            }
+            else if (state === "merged") {
+                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 === "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}`);
+        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;
+    }
+    const git = await readGitInfo(cwd);
+    if (!git.isRepo) {
+        log.error("Not a git repository.");
+        process.exitCode = 1;
+        return;
+    }
+    if (git.branch === taskBranch) {
+        log.info(dim(`On ${taskBranch} — switching to ${integrationBranch} first.`));
+    }
+    try {
+        await gitFetchRemote(cwd, remote);
+        log.ok(`Fetched ${remote} (--prune)`);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        log.warn(`git fetch failed (${msg}). Continuing with local refs.`);
+    }
+    const switched = await gitSwitchToBranch(cwd, integrationBranch, remote);
+    if (!switched) {
+        log.error(`Integration branch "${integrationBranch}" not found locally or on ${remote}.`);
+        process.exitCode = 1;
+        return;
+    }
+    log.ok(`On ${integrationBranch}`);
+    if (await gitRemoteBranchExists(cwd, remote, integrationBranch)) {
+        try {
+            await gitPullFastForwardOnly(cwd, remote, integrationBranch);
+            log.ok(`Up to date with ${remote}/${integrationBranch} (--ff-only)`);
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            log.error(`Could not fast-forward ${integrationBranch}: ${msg}. Resolve locally, then rerun.`);
+            process.exitCode = 1;
+            return;
+        }
+    }
+    else {
+        log.warn(`No ${remote}/${integrationBranch} — skipped pull.`);
+    }
+    if (await gitBranchExists(cwd, taskBranch)) {
+        try {
+            await gitDeleteBranch(cwd, taskBranch, { force: options.force === true });
+            log.ok(`Deleted local branch ${taskBranch}`);
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            log.error(`Could not delete local ${taskBranch}: ${msg}`);
+            log.info(dim("Merge the MR into the integration branch first, or rerun with --force (discards unmerged branch)."));
+            process.exitCode = 1;
+            return;
+        }
+    }
+    else {
+        log.info(dim(`Local branch ${taskBranch} not found — skipped.`));
+    }
+    if (options.noRemoteDelete !== true && (await gitRemoteBranchExists(cwd, remote, taskBranch))) {
+        try {
+            await gitDeleteRemoteBranch(cwd, remote, taskBranch);
+            log.ok(`Deleted ${remote}/${taskBranch}`);
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            log.warn(`Could not delete remote ${taskBranch}: ${msg}`);
+            log.info(dim(`Delete manually: git push ${remote} --delete ${taskBranch}`));
+        }
+    }
+    else if (options.noRemoteDelete === true) {
+        log.info(dim("Remote branch delete skipped (--no-remote-delete)."));
+    }
+    else {
+        log.info(dim(`No ${remote}/${taskBranch} — skipped remote delete.`));
+    }
+    log.blank();
+    log.info(`Next: ${cyan("vibeops task add")}`);
+}

package/dist/lib/git.js

@@ -495,6 +495,13 @@ export async function gitFetch(cwd, remote, ref) {
         args.push(ref);
     await runGit(cwd, args);
 }
+/** Fetch all refs from `remote` and prune deleted remote-tracking branches. */
+export async function gitFetchRemote(cwd, remote) {
+    await runGit(cwd, ["fetch", remote, "--prune"]);
+}
+export async function gitDeleteRemoteBranch(cwd, remote, branch) {
+    await runGit(cwd, ["push", remote, "--delete", branch]);
+}
 export async function gitPullFastForwardOnly(cwd, remote, branch) {
     await runGit(cwd, ["pull", "--ff-only", remote, branch]);
 }

package/dist/lib/paths.js

@@ -22,7 +22,7 @@ export function projectPaths(root) {
         gitignore: join(abs, ".gitignore"),
     };
 }
-/** Project memory files updated by `vibeops task done`. */
+/** Project memory files updated by `vibeops task ship`. */
 export const PROJECT_MEMORY_FILES = {
     currentState: "docs/project/05-current-state.md",
     architecture: "docs/project/03-architecture.md",

package/dist/lib/pr-create.js

@@ -64,3 +64,66 @@ export async function probeMergeRequestCli(host) {
         return false;
     }
 }
+function prRefFromUrl(url) {
+    const trimmed = url.trim();
+    const pullMatch = /\/pull\/(\d+)/i.exec(trimmed);
+    if (pullMatch)
+        return pullMatch[1];
+    const mrMatch = /\/merge_requests\/(\d+)/i.exec(trimmed);
+    if (mrMatch)
+        return mrMatch[1];
+    if (/^\d+$/.test(trimmed))
+        return trimmed;
+    return trimmed;
+}
+export async function getMergeRequestState(cwd, host, url) {
+    const ref = prRefFromUrl(url);
+    try {
+        if (host === "gitlab") {
+            const { stdout } = await execFileAsync("glab", ["mr", "view", ref, "--output", "json", "state"], { cwd, maxBuffer: 1024 * 1024 });
+            const state = stdout.trim().toLowerCase();
+            if (state === "merged")
+                return "merged";
+            if (state === "opened" || state === "open")
+                return "open";
+            if (state === "closed")
+                return "closed";
+            return "unknown";
+        }
+        const { stdout } = await execFileAsync("gh", ["pr", "view", ref, "--json", "state", "-q", ".state"], { cwd, maxBuffer: 1024 * 1024 });
+        const state = stdout.trim().toUpperCase();
+        if (state === "MERGED")
+            return "merged";
+        if (state === "OPEN")
+            return "open";
+        if (state === "CLOSED")
+            return "closed";
+        return "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}
+export async function mergeMergeRequest(opts) {
+    const ref = prRefFromUrl(opts.url);
+    const method = opts.method ?? "squash";
+    const label = mergeRequestLabel(opts.host);
+    if (opts.dryRun === true) {
+        if (opts.host === "gitlab") {
+            log.info(`would ${label} merge ${ref} (glab mr merge)`);
+        }
+        else {
+            log.info(`would gh pr merge ${ref} --${method}`);
+        }
+        return;
+    }
+    if (opts.host === "gitlab") {
+        await execFileAsync("glab", ["mr", "merge", ref], {
+            cwd: opts.cwd,
+            maxBuffer: 4 * 1024 * 1024,
+        });
+        return;
+    }
+    const args = ["pr", "merge", ref, `--${method}`];
+    await execFileAsync("gh", args, { cwd: opts.cwd, maxBuffer: 4 * 1024 * 1024 });
+}

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;
@@ -30,5 +30,5 @@ export function taskNotFoundMessage(taskRef) {
     if (taskRef?.trim()) {
         return `TASK not found: ${normalizeTaskRef(taskRef)}. Check docs/tasks/.`;
     }
-    return "No open TASK found. Run `vibeops task add` or pass `vibeops task done TASK-NNN`.";
+    return "No open TASK found. Run `vibeops task add` or pass `vibeops task ship TASK-NNN`.";
 }

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,8 +1,9 @@
 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 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);
@@ -11,7 +12,7 @@ export async function findBlockingTask(paths, cwd) {
     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))
@@ -21,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, "/");
@@ -32,12 +43,17 @@ export function computeNextHint(input) {
         return "init";
     if (input.focus === null)
         return "task-add";
-    if (input.focus.status === "done")
+    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";
     }
-    return "task-done";
+    return input.hasMergeRequest ? "task-merge" : "task-ship";
 }
 export function hintToText(hint, cwd, task) {
     switch (hint) {
@@ -45,15 +61,23 @@ export function hintToText(hint, cwd, task) {
             return "Run `vibeops init` in this directory.";
         case "task-add":
             return "Run `vibeops task add` to start the next slice.";
-        case "task-done":
-            return task ? `Run \`vibeops task done ${task.id}\`.` : "Run `vibeops task done`.";
+        case "task-ship":
+            return task ? `Run \`vibeops task ship ${task.id}\`.` : "Run `vibeops task ship`.";
+        case "task-merge":
+            return task
+                ? `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
+                ? `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.`
                 : "Open the TASK file in Cursor Ask.";
         case "cursor-implement":
             return task
-                ? `In Cursor Agent: @${relPath(cwd, task.filePath)} — implement, then task done.`
+                ? `In Cursor Agent: @${relPath(cwd, task.filePath)} — implement, then task ship.`
                 : "Implement per the TASK file in Cursor.";
     }
 }
@@ -66,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-git-commit.js

@@ -0,0 +1,32 @@
+import { dim, log } from "./logger.js";
+import { gitAddPaths, gitPush, listWorkingTreeRelPaths, partitionPathsForAutoCommit, readGitInfo, runGit, } from "./git.js";
+export function featCommitMessageFor(taskId, title) {
+    const slug = title.replace(/^TASK-\d+\s*[:\-]\s*/i, "").trim() || taskId;
+    return `feat(${taskId.toLowerCase()}): ${slug}`;
+}
+export function docsCommitMessageFor(taskId, suffix) {
+    return `docs(${taskId.toLowerCase()}): ${suffix}`;
+}
+/** Commit all committable dirty paths; returns whether a commit was created. */
+export async function commitDirtyWorkingTree(cwd, message, dryRun) {
+    const git = await readGitInfo(cwd);
+    if (!git.isRepo || git.dirty !== true)
+        return false;
+    const { committable, excluded } = partitionPathsForAutoCommit(await listWorkingTreeRelPaths(cwd), { unmerged: [] });
+    if (committable.length === 0)
+        return false;
+    if (excluded.length > 0) {
+        log.warn(`Skipping ${excluded.length} build artifact path(s) from auto-commit.`);
+    }
+    if (dryRun) {
+        log.info(dim(`  would commit ${committable.length} path(s): ${message}`));
+        return true;
+    }
+    await gitAddPaths(cwd, committable);
+    await runGit(cwd, ["commit", "-q", "-m", message]);
+    log.ok(`Committed: ${message}`);
+    return true;
+}
+export async function pushBranch(cwd, remote, branch, setUpstream) {
+    await gitPush(cwd, remote, branch, setUpstream);
+}