@goodtek/vibeops 1.1.1 → 2.0.0

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

@@ -1,37 +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 { gitAddPaths, 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}`;
-}
-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.`);
+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 commit ship metadata"));
+        if (opts.push !== null) {
+            log.info(dim(`  would git push ${opts.push.remote} ${opts.push.branch} (review metadata)`));
+        }
+        return true;
     }
-    if (dryRun) {
-        log.info(dim(`  would commit ${committable.length} path(s)`));
+    await updateInlineStatus(opts.taskFile, "review");
+    log.ok("Status → Review");
+    const committed = await commitDirtyWorkingTree(opts.cwd, docsCommitMessageFor(opts.taskId, "ready for review"), false);
+    if (!committed) {
+        log.warn("No file changes for review metadata commit — check TASK Status on the remote branch.");
         return true;
     }
-    await gitAddPaths(cwd, committable);
-    await runGit(cwd, ["commit", "-q", "-m", message]);
-    log.ok(`Committed: ${message}`);
-    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}`);
+        return true;
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        log.error(`Review 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;
@@ -45,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");
@@ -56,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,
@@ -66,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)
@@ -96,19 +104,29 @@ export async function taskDoneCommand(taskRef, options = {}) {
         if (!resultOk || !testOk) {
             log.info("  · LLM fill Result / Test Result + patch docs/project/*");
         }
-        log.info("  · commit if dirty, push task branch, open MR/PR (unless --no-pr)");
-        log.info("  · Status → Done after push/MR succeed");
+        log.info("  · commit implementation, push task branch, open MR/PR (unless --no-pr)");
+        log.info("  · Status → Review; commit metadata; push again");
         await finishTaskWithPullRequest({
             cwd,
             taskFile,
             dryRun: true,
             skipPr: options.noPr === true,
         });
+        const gitCtxDry = await readGitContext(taskFile);
+        const gitCfgDry = gitCtxDry !== null ? await requireGitConfig(cwd).catch(() => null) : null;
+        await commitShipMetadataAndPush({
+            cwd,
+            taskFile,
+            taskId,
+            dryRun: true,
+            push: gitCtxDry !== null && gitCfgDry !== null
+                ? { remote: gitCfgDry.remote, branch: gitCtxDry.taskBranch }
+                : null,
+        });
         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({
@@ -117,21 +135,41 @@ 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 {
         log.info(dim("No Git Context — push/MR skipped."));
     }
-    await updateInlineStatus(taskFile, "done");
-    await markGitContextDone(taskFile);
-    log.ok("Status → Done");
+    const gitCtxAfter = await readGitContext(taskFile);
+    let pushTarget = null;
+    if (gitCtxAfter !== null) {
+        try {
+            const gitCfg = await requireGitConfig(cwd);
+            pushTarget = { remote: gitCfg.remote, branch: gitCtxAfter.taskBranch };
+        }
+        catch (e) {
+            if (e instanceof Error)
+                log.warn(e.message);
+        }
+    }
+    const shipped = await commitShipMetadataAndPush({
+        cwd,
+        taskFile,
+        taskId: parts.id,
+        dryRun: false,
+        push: pushTarget,
+    });
+    if (!shipped) {
+        log.error("Review metadata push failed — fix manually, then run task merge.");
+        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,183 @@
+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 { getMergeRequestState, 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 { resolveLifecycleTarget } from "../lib/task-lifecycle-target.js";
+import { markGitContextDone, readGitContext, readTaskFile, updateInlineStatus, } 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.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 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 (meta.status === "review") {
+        log.warn(`${yellow("Status")} is Review — merge the MR first, 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.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.`);
+    }
+    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 });
+            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

@@ -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-context.js

@@ -2,12 +2,15 @@ import { relative } from "node:path";
 import { gitBranchExists, readGitInfo } from "./git.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. */
+/** TASK that blocks `task add` — in progress, in review, or open on current task branch. */
 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) {
@@ -32,12 +35,16 @@ export function computeNextHint(input) {
         return "init";
     if (input.focus === null)
         return "task-add";
-    if (input.focus.status === "done")
-        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.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 +52,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
+                ? `Run \`vibeops task merge ${task.id}\`, then task sync.`
+                : "Run `vibeops task merge` after the MR is ready.";
+        case "task-sync":
+            return task
+                ? `MR merged? Run \`vibeops task sync ${task.id}\`, then task add.`
+                : "Run `vibeops task sync` after merging the MR.";
         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.";
     }
 }

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);
+}

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

@@ -0,0 +1,41 @@
+import { readGitInfo } from "./git.js";
+import { isOnTaskBranch, loadActionableTasks, pickLatestReviewTask, 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) {
+    const trimmed = taskRef?.trim();
+    if (trimmed !== undefined && trimmed.length > 0) {
+        const resolved = await resolveTask(paths, cwd, trimmed);
+        if (resolved === null)
+            return null;
+        const ctx = await readGitContext(resolved.taskFile);
+        if (ctx === null)
+            return null;
+        return {
+            taskId: resolved.taskId,
+            taskBranch: ctx.taskBranch,
+            taskFile: resolved.taskFile,
+        };
+    }
+    const git = await readGitInfo(cwd);
+    if (git.isRepo && typeof git.branch === "string" && git.branch.startsWith("task/")) {
+        const tasks = await loadActionableTasks(paths.docsTasks);
+        for (const t of tasks) {
+            const ctx = await readGitContext(t.filePath);
+            if (isOnTaskBranch(git.branch, ctx)) {
+                return { taskId: t.id, taskBranch: git.branch, taskFile: t.filePath };
+            }
+        }
+    }
+    const review = pickLatestReviewTask(await loadActionableTasks(paths.docsTasks));
+    if (review === null)
+        return null;
+    const ctx = await readGitContext(review.filePath);
+    if (ctx === null)
+        return null;
+    return {
+        taskId: review.id,
+        taskBranch: ctx.taskBranch,
+        taskFile: review.filePath,
+    };
+}

package/dist/lib/task-scaffold.js

@@ -45,7 +45,7 @@ ${draft.idea.trim()}
 ## Acceptance Criteria
 
 1. Goal and Scope are met and verifiable via Test Plan.
-2. Result and Test Result are filled before \`vibeops task done\`.
+2. Result and Test Result are filled before \`vibeops task ship\`.
 
 ## Test Plan
 

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

@@ -17,7 +17,7 @@ function localDateFilename() {
 async function readOptional(path) {
     return readTextOrNull(path);
 }
-export async function llmCompleteTaskDone(params) {
+export async function llmCompleteTaskShip(params) {
     const git = await readGitInfo(params.cwd);
     let diffSummary = "";
     if (git.isRepo) {
@@ -31,7 +31,7 @@ export async function llmCompleteTaskDone(params) {
     const messages = [
         {
             role: "system",
-            content: `You close a VibeOps TASK. Reply with JSON only:
+            content: `You ship a VibeOps TASK for review. 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} done.`,
+                : `${params.taskId} shipped for review.`,
             provider,
         };
     }
@@ -99,7 +99,7 @@ Be factual. Do not invent files not in the diff.`,
         return null;
     }
 }
-export async function applyTaskDoneMemory(cwd, patch) {
+export async function applyTaskShipMemory(cwd, patch) {
     const paths = projectPaths(cwd);
     const updated = [];
     const skipped = [];
@@ -142,12 +142,15 @@ export async function writeTaskResultSections(taskFile, result, testResult) {
     await updateTaskSection(taskFile, "Result", result);
     await updateTaskSection(taskFile, "Test Result", testResult);
 }
-/** Minimal fallback when LLM unavailable — git-only sections from diff. */
 export async function fallbackResultSections(cwd, taskId, taskFile) {
     const names = await gitDiffNameOnly(cwd);
     const body = await readText(taskFile);
     const goal = readSection(body, "Goal").slice(0, 200);
-    const result = [`Completed ${taskId}.`, goal.length > 0 ? `Goal: ${goal}` : "", names.length > 0 ? `Paths: ${names.slice(0, 15).join(", ")}` : ""]
+    const result = [
+        `Shipped ${taskId} for review.`,
+        goal.length > 0 ? `Goal: ${goal}` : "",
+        names.length > 0 ? `Paths: ${names.slice(0, 15).join(", ")}` : "",
+    ]
         .filter((l) => l.length > 0)
         .join("\n");
     const testResult = names.length > 0 ? `Changed: ${names.join(", ")}` : "Manual verification required.";