@goodtek/vibeops 2.3.0 → 2.4.0

package/CHANGELOG.md

@@ -4,6 +4,26 @@ All notable changes to VibeOps are documented here.
 
 ## Unreleased
 
+## 2.4.0 - 2026-06-12
+
+### Changed
+
+- **`vibeops task ship` is now state-aware.** It detects the TASK's PR/MR state and branches:
+  1. **No PR** → push + open a new PR (first submit, Status → Shipped).
+  2. **Open PR (unmerged)** → commit + push the **same** branch to update the existing PR (no new PR); CI re-runs. This replaces the manual `git add/commit/push` loop.
+  3. **Merged PR** → start a **new** PR cycle (former `reship`), guarded by an interactive confirm (`This starts a NEW PR cycle after merge. Continue? (y/N)`) or `--new-cycle` in non-interactive mode.
+- Every path prints a one-line summary: `Created PR #<n> → <url>`, `Updated existing PR #<n> (pushed <sha>) — CI re-running`, `Started new PR cycle → PR #<n>`, or `Nothing to ship (working tree clean, PR #<n> up to date)`.
+- Commit messages are auto-scoped with the TASK id (`feat(task-001): …`). `ship` refuses when HEAD is not the TASK branch.
+- PR/MR state resolution is unified in a single source (`resolveTaskMergeRequestLifecycle`).
+
+### Added
+
+- **`vibeops task ship`** flags: `-m/--message <msg>` (TASK id auto-prefixed; LLM-drafted or prompted when omitted), `--new-cycle` (alias `--reship`), `--no-commit` (push committed history only), `--non-interactive`.
+
+### Deprecated
+
+- **`vibeops task reship`** is now a thin alias for `vibeops task ship --new-cycle` and prints a deprecation notice.
+
 ## 2.3.0 - 2026-06-09
 
 ### Added

package/README.md

@@ -14,8 +14,8 @@ 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 del` | Cancel TASK before merge (md + branch + close open MR) |
-| `vibeops task ship` | LLM summary, commit, push, open MR/PR (Status → **Shipped**) |
-| `vibeops task reship` | Shipped follow-up: move uncommitted work to task branch, commit, new MR/PR (Status stays Shipped) |
+| `vibeops task ship` | State-aware submit: open a new PR · update the open PR · start a new PR cycle after merge (Status → **Shipped**) |
+| `vibeops task reship` | **Deprecated** alias for `task ship --new-cycle` |
 | `vibeops task merge` | Merge TASK MR/PR into integration branch (default: squash) |
 | `vibeops task sync` | After merge: ff-only integration pull, delete task branches (no TASK md edits) |
 | `vibeops task release` | Release PR: integration → production (GitFlow) |
@@ -56,13 +56,24 @@ vibeops task add
 vibeops task ship
 vibeops task merge
 vibeops pull
-# Follow-up on same TASK (after merge):
-vibeops task reship TASK-NNN
+# Same TASK, before merge — edit, then just re-run ship (updates the open PR):
+vibeops task ship -m "address review"
+# Same TASK, after merge — start a new PR cycle:
+vibeops task ship --new-cycle
 vibeops task merge
 vibeops task sync
 vibeops task add
 ```
 
+`ship` detects the TASK's PR state and does the right thing:
+
+| State | `ship` does | Output |
+|-------|-------------|--------|
+| No PR yet | push + open a new PR | `Created PR #<n> → <url>` |
+| PR open (unmerged) | commit + push the **same** branch (no new PR), CI re-runs | `Updated existing PR #<n> (pushed <sha>) — CI re-running` |
+| PR merged | start a **new** PR cycle (needs confirm or `--new-cycle`) | `Started new PR cycle → PR #<n>` |
+| No change | no-op | `Nothing to ship (working tree clean, PR #<n> up to date)` |
+
 Occasionally (GitFlow release to production):
 
 ```bash
@@ -73,7 +84,7 @@ Only one TASK **In Progress** at a time (`task add` blocks otherwise). **Shipped
 
 ## LLM (optional)
 
-For **`task add`** / **`task ship`** / **`task reship`** only (not for coding in the IDE):
+For **`task add`** / **`task ship`** only (not for coding in the IDE). When `-m` is omitted, `ship` uses a connected provider to draft the commit subject:
 
 ```bash
 vibeops llm connect
@@ -99,8 +110,8 @@ 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 del`**: `--dry-run`, `--force`, `--no-remote-delete`, `--no-close-mr`
-- **`task ship`**: `--dry-run`, `--no-pr`
-- **`task reship`**: `--dry-run`, `--no-pr`, `--no-integrate`, `--recreate-branch`, `--skip-llm`, `--allow-open-mr`
+- **`task ship`**: `-m/--message`, `--new-cycle` (alias `--reship`), `--no-commit`, `--dry-run`, `--no-pr`, `--non-interactive`, `--allow-open-mr`, `--no-integrate`, `--recreate-branch`, `--skip-llm`
+- **`task reship`** (deprecated): `--dry-run`, `--no-pr`, `--no-integrate`, `--recreate-branch`, `--skip-llm`, `--allow-open-mr` → delegates to `task ship --new-cycle`
 - **`task merge`**: `--dry-run`, `--merge`, `--rebase`
 - **`task sync`**: `--dry-run`, `--no-remote-delete`, `--force`
 - **`task release`**: `--dry-run`, `--no-merge`, `--merge`, `--rebase`
@@ -111,8 +122,8 @@ 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 implementation + ship metadata (Status **Shipped**) → push once → MR/PR (URL on host; `task merge` resolves by branch).
-- **`task reship`**: Shipped TASK follow-up — carries uncommitted work onto the task branch (creates it from integration when missing after sync), integrates `develop`, commit → push → **new** PR.
+- **`task ship`** (state-aware): **no PR** → commit + ship metadata (Status **Shipped**) → push → open MR/PR; **open PR** → commit + push the same branch, CI re-runs, no new PR; **merged PR** → new PR cycle (carries uncommitted work onto the task branch, integrates `develop`, opens a **new** PR). Commit messages are TASK-id-scoped (`feat(task-001): …`). Refuses when HEAD is not the task branch.
+- **`task reship`** *(deprecated)*: alias for `task ship --new-cycle`.
 - **`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).
 - **`pull`**: fetch + switch to integration branch + `git pull --ff-only` (one command).

package/dist/cli.js

@@ -96,20 +96,37 @@ task
 });
 task
     .command("ship [taskRef]")
-    .description("Submit TASK: LLM summary, commit, push, open MR/PR (Status → Shipped)")
+    .description("State-aware submit: new PR · update open PR · new PR cycle after merge (Status → Shipped)")
     .option("--dry-run", "Plan only")
+    .option("-m, --message <msg>", "Commit message (TASK id auto-prefixed; LLM/prompt when omitted)")
+    .option("--new-cycle", "Allow a new PR cycle after merge without prompting (alias: --reship)")
+    .option("--reship", "Alias for --new-cycle")
+    .option("--no-commit", "Push already-committed changes only (skip staging/commit)")
     .option("--no-pr", "Push only; skip creating MR/PR")
+    .option("--non-interactive", "CI: never prompt")
+    .option("--no-integrate", "New PR cycle: skip merging integration into the task branch")
+    .option("--recreate-branch", "New PR cycle: recreate task branch from integration")
+    .option("--skip-llm", "New PR cycle: do not run LLM for Result / Test Result")
+    .option("--allow-open-mr", "Update the open MR/PR with new commits instead of a new cycle")
     .option("--cwd <path>", "Target directory")
     .action(async (taskRef, opts) => {
     await taskShipCommand(taskRef, {
         dryRun: Boolean(opts.dryRun),
-        noPr: Boolean(opts.noPr),
+        message: opts.message,
+        newCycle: Boolean(opts.newCycle) || Boolean(opts.reship),
+        noCommit: opts.commit === false,
+        noPr: opts.pr === false,
+        nonInteractive: Boolean(opts.nonInteractive),
+        noIntegrate: opts.integrate === false,
+        recreateBranch: Boolean(opts.recreateBranch),
+        skipLlm: Boolean(opts.skipLlm),
+        allowOpenMr: Boolean(opts.allowOpenMr),
         cwd: opts.cwd,
     });
 });
 task
     .command("reship [taskRef]")
-    .description("Follow-up on Shipped TASK: move uncommitted work to task branch, commit, new MR/PR")
+    .description("Deprecated alias for `task ship --new-cycle` (start a new PR cycle after merge)")
     .option("--dry-run", "Plan only")
     .option("--no-pr", "Push only; skip creating MR/PR")
     .option("--no-integrate", "Skip merging integration branch into task branch")
@@ -120,8 +137,8 @@ task
     .action(async (taskRef, opts) => {
     await taskReshipCommand(taskRef, {
         dryRun: Boolean(opts.dryRun),
-        noPr: Boolean(opts.noPr),
-        noIntegrate: Boolean(opts.noIntegrate),
+        noPr: opts.pr === false,
+        noIntegrate: opts.integrate === false,
         recreateBranch: Boolean(opts.recreateBranch),
         skipLlm: Boolean(opts.skipLlm),
         allowOpenMr: Boolean(opts.allowOpenMr),

package/dist/commands/task-reship.js

@@ -1,175 +1,21 @@
-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, } 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, } from "../lib/task.js";
-import { listWorkingTreeRelPaths } from "../lib/git.js";
-async function commitReshipMetadata(opts) {
-    if (opts.dryRun) {
-        log.info(dim("  would commit reship metadata (Status stays Shipped)"));
-        return;
-    }
-    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)."));
-    }
-}
+import { dim, log, yellow } from "../lib/logger.js";
+import { taskShipCommand } from "./task-ship.js";
+/**
+ * @deprecated `reship` is now `vibeops task ship --new-cycle`.
+ * Kept as a thin alias for backward compatibility.
+ */
 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";
-    const updateOpenMr = options.allowOpenMr === true;
-    if (!dryRun && !(await assertMergeRequestNotOpen(cwd, taskFile, updateOpenMr))) {
-        process.exitCode = 1;
-        return;
-    }
-    const branchOk = await ensureTaskBranchForReship({
-        cwd,
-        taskFile,
-        gitCtx: initialCtx,
-        integrationBranch,
-        remote,
-        recreateBranch: options.recreateBranch === true,
-        dryRun,
-    });
-    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.warn(`${yellow("reship is now `ship` (deprecated alias)")} — delegating to \`vibeops task ship --new-cycle\`.`);
+    log.info(dim("Run `vibeops task ship` directly; it detects first submit / open-PR update / new PR cycle."));
     log.blank();
-    if (dryRun) {
-        log.info(bold("dry-run — would also:"));
-        if (updateOpenMr) {
-            log.info("  · feat commit, push, update open MR/PR (unless --no-pr)");
-        }
-        else {
-            log.info("  · feat commit + reship metadata, then push once and open MR/PR (unless --no-pr)");
-        }
-        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 (e.g. on develop), 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;
-    }
-    if (updateOpenMr) {
-        log.info(dim("Updating open MR/PR (--allow-open-mr)."));
-    }
-    else {
-        gitCtx = await refreshGitContextBaseCommit(taskFile, gitCtx, cwd);
-        gitCtx = await prepareGitContextForReship(cwd, taskFile, gitCtx);
-        await commitReshipMetadata({
-            cwd,
-            taskFile,
-            taskId: parts.id,
-            dryRun: false,
-        });
-    }
-    const prResult = await finishTaskWithPullRequest({
-        cwd,
-        taskFile,
-        skipPr: options.noPr === true,
-        forceNewMergeRequest: !updateOpenMr,
+    await taskShipCommand(taskRef, {
+        dryRun: options.dryRun,
+        cwd: options.cwd,
+        noPr: options.noPr,
+        newCycle: true,
+        noIntegrate: options.noIntegrate,
+        recreateBranch: options.recreateBranch,
+        skipLlm: options.skipLlm,
+        allowOpenMr: options.allowOpenMr,
     });
-    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}`);
-    }
-    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

@@ -1,13 +1,55 @@
 import { resolve } from "node:path";
 import { readText } from "../lib/filesystem.js";
+import { requireGitConfig } from "../lib/git-config.js";
+import { gitCommitsAhead, gitHeadCommit, gitPush, gitRemoteBranchExists, readGitInfo, } from "../lib/git.js";
+import { askYesNo, isInteractiveSession } from "../lib/inquirer-helpers.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 { prNumberFromUrl } from "../lib/pr-create.js";
+import { resolveShipTarget, taskNotFoundMessage } from "../lib/resolve-task.js";
 import { relPath } from "../lib/task-context.js";
-import { commitDirtyWorkingTree, docsCommitMessageFor, featCommitMessageFor, } from "../lib/task-git-commit.js";
+import { resolveShipCommitMessage } from "../lib/task-commit-msg.js";
+import { commitDirtyWorkingTree, docsCommitMessageFor, } from "../lib/task-git-commit.js";
+import { runPostMergeNewCycle } from "../lib/task-new-cycle.js";
 import { applyTaskShipMemory, fallbackResultSections, llmCompleteTaskShip, writeTaskResultSections, } from "../lib/task-ship-llm.js";
+import { detectShipPrState, prRefLabel, resolveShipAction, } from "../lib/task-ship-state.js";
 import { finishTaskWithPullRequest } from "../lib/task-push-pr.js";
 import { hasNonEmptySection, parseTaskFilename, readGitContext, readTaskFile, updateInlineStatus, } from "../lib/task.js";
+function describePushFailure(message) {
+    const lower = message.toLowerCase();
+    if (lower.includes("protected") ||
+        lower.includes("pre-receive") ||
+        lower.includes("gh006") ||
+        lower.includes("hook declined")) {
+        return "Push rejected by branch protection. Adjust the rule on the host (or push via the MR), then rerun.";
+    }
+    if (lower.includes("non-fast-forward") ||
+        lower.includes("fetch first") ||
+        lower.includes("rejected") ||
+        lower.includes("behind")) {
+        return "Push rejected — the remote branch has commits you don't. Pull/rebase the task branch, then rerun.";
+    }
+    return `git push failed: ${message}`;
+}
+function warnPlaceholderSections(body) {
+    const resultOk = hasNonEmptySection(body, "Result");
+    const testOk = hasNonEmptySection(body, "Test Result");
+    if (!resultOk || !testOk) {
+        log.warn("Result / Test Result still look like placeholders (docs-before-ship). Update the TASK file before merge.");
+    }
+}
+async function ensureOnTaskBranch(cwd, gitCtx, dryRun) {
+    const git = await readGitInfo(cwd);
+    if (git.branch === gitCtx.taskBranch)
+        return true;
+    const where = git.branch ?? "(detached)";
+    if (dryRun) {
+        log.warn(`Current branch is ${where}, not ${gitCtx.taskBranch}.`);
+        return true;
+    }
+    log.error(`On ${where}, not ${gitCtx.taskBranch}. Switch with \`git switch ${gitCtx.taskBranch}\` and rerun.`);
+    return false;
+}
 async function commitShipMetadata(opts) {
     if (opts.dryRun) {
         log.info(dim("  would set Status → Shipped"));
@@ -21,23 +63,10 @@ async function commitShipMetadata(opts) {
         log.warn("No file changes for ship metadata commit — check TASK Status on the remote branch.");
     }
 }
-export async function taskShipCommand(taskRef, options = {}) {
-    const cwd = resolve(options.cwd ?? process.cwd());
-    const paths = projectPaths(cwd);
-    const dryRun = options.dryRun === true;
-    const resolved = await resolveTask(paths, cwd, taskRef);
-    if (resolved === null) {
-        log.error(taskNotFoundMessage(taskRef));
-        process.exitCode = 1;
-        return;
-    }
-    const { taskId, taskFile } = resolved;
-    const meta = await readTaskFile(taskFile);
-    const body = await readText(taskFile);
-    const relFile = relPath(cwd, taskFile);
-    log.info(bold(`vibeops task ship ${taskId}`));
-    log.info(`  ${dim("file")}  ${relFile}`);
-    log.blank();
+/** State 1: first submit — push the task branch and open a new PR/MR. */
+async function runFirstShip(ctx) {
+    const { cwd, taskId, taskFile, meta, relFile, dryRun, nonInteractive, options } = ctx;
+    let body = ctx.body;
     let resultOk = hasNonEmptySection(body, "Result");
     let testOk = hasNonEmptySection(body, "Test Result");
     if (!resultOk || !testOk) {
@@ -68,9 +97,9 @@ export async function taskShipCommand(taskRef, options = {}) {
                 await writeTaskResultSections(taskFile, fb.result, fb.testResult);
             }
         }
-        const body2 = dryRun ? body : await readText(taskFile);
-        resultOk = hasNonEmptySection(body2, "Result");
-        testOk = hasNonEmptySection(body2, "Test Result");
+        body = dryRun ? body : await readText(taskFile);
+        resultOk = hasNonEmptySection(body, "Result");
+        testOk = hasNonEmptySection(body, "Test Result");
     }
     log.info(bold("Sections"));
     log.info(`  ${resultOk ? green("✓") : yellow("·")} Result`);
@@ -86,15 +115,10 @@ export async function taskShipCommand(taskRef, options = {}) {
         if (!resultOk || !testOk) {
             log.info("  · LLM fill Result / Test Result + patch docs/project/*");
         }
-        log.info("  · commit implementation + ship metadata (Status → Shipped)");
-        log.info("  · push task branch once, open MR/PR (unless --no-pr)");
+        log.info("  · commit implementation (TASK-scoped message) + ship metadata (Status → Shipped)");
+        log.info("  · push task branch once, open a new MR/PR (unless --no-pr)");
         const partsDry = parseTaskFilename(taskFile);
-        await commitShipMetadata({
-            cwd,
-            taskFile,
-            taskId: partsDry.id,
-            dryRun: true,
-        });
+        await commitShipMetadata({ cwd, taskFile, taskId: partsDry.id, dryRun: true });
         await finishTaskWithPullRequest({
             cwd,
             taskFile,
@@ -103,33 +127,223 @@ export async function taskShipCommand(taskRef, options = {}) {
         });
         return;
     }
-    const parts = parseTaskFilename(taskFile);
-    await commitDirtyWorkingTree(cwd, featCommitMessageFor(parts.id, meta.title), false);
     const gitCtx = await readGitContext(taskFile);
-    if (gitCtx !== null) {
-        await commitShipMetadata({
+    if (gitCtx !== null && !(await ensureOnTaskBranch(cwd, gitCtx, dryRun))) {
+        process.exitCode = 1;
+        return;
+    }
+    const parts = parseTaskFilename(taskFile);
+    if (options.noCommit === true) {
+        const git = await readGitInfo(cwd);
+        if (git.dirty === true) {
+            log.warn("Uncommitted changes left in place (--no-commit); committing ship metadata only.");
+        }
+    }
+    else {
+        const message = await resolveShipCommitMessage({
             cwd,
-            taskFile,
             taskId: parts.id,
-            dryRun: false,
+            title: meta.title,
+            provided: options.message,
+            nonInteractive,
         });
-        const prResult = await finishTaskWithPullRequest({
+        await commitDirtyWorkingTree(cwd, message, false);
+    }
+    if (gitCtx === null) {
+        log.info(dim("No Git Context — push/MR skipped."));
+        return;
+    }
+    await commitShipMetadata({ cwd, taskFile, taskId: parts.id, dryRun: false });
+    const prResult = await finishTaskWithPullRequest({
+        cwd,
+        taskFile,
+        skipPr: options.noPr === true,
+    });
+    if (!prResult.ok) {
+        log.error("TASK left In Progress — fix push/MR, then rerun task ship.");
+        process.exitCode = 1;
+        return;
+    }
+    log.blank();
+    if (prResult.mergeRequestUrl && prResult.mergeRequestUrl !== "(dry-run)") {
+        const ref = prRefLabel(prNumberFromUrl(prResult.mergeRequestUrl));
+        log.ok(`Created PR ${ref} → ${prResult.mergeRequestUrl}`);
+    }
+    else if (options.noPr === true) {
+        log.ok(`Pushed ${gitCtx.taskBranch} (no PR created — --no-pr).`);
+    }
+    else {
+        log.ok(`Pushed ${gitCtx.taskBranch} (create the MR/PR manually).`);
+    }
+    log.info(`Next: ${cyan("vibeops task merge")} (or merge in the host UI), then ${cyan("vibeops task sync")}`);
+}
+/** State 2: an open PR exists — commit + push to update it (no new PR). */
+async function runUpdateOpenPr(ctx) {
+    const { cwd, taskId, taskFile, meta, body, prCtx, dryRun, nonInteractive, options } = ctx;
+    const gitCtx = await readGitContext(taskFile);
+    if (gitCtx === null) {
+        log.error("No Git Context — cannot update the open PR.");
+        process.exitCode = 1;
+        return;
+    }
+    let gitCfg;
+    try {
+        gitCfg = await requireGitConfig(cwd);
+    }
+    catch (e) {
+        log.error(e instanceof Error ? e.message : String(e));
+        process.exitCode = 1;
+        return;
+    }
+    const remote = gitCfg.remote;
+    if (!(await ensureOnTaskBranch(cwd, gitCtx, dryRun))) {
+        process.exitCode = 1;
+        return;
+    }
+    warnPlaceholderSections(body);
+    if (dryRun) {
+        log.info(bold("dry-run — would:"));
+        if (options.noCommit === true) {
+            log.info("  · skip commit (--no-commit); push committed history only");
+        }
+        else {
+            log.info("  · commit working tree with a TASK-scoped message");
+        }
+        log.info(`  · push ${gitCtx.taskBranch} → ${remote} (no new PR)`);
+        log.info(`  · update existing PR ${prRefLabel(prCtx.number)} — CI re-runs`);
+        return;
+    }
+    if (meta.status === "in_progress") {
+        await updateInlineStatus(taskFile, "shipped");
+        log.ok("Status → Shipped");
+        await commitDirtyWorkingTree(cwd, docsCommitMessageFor(taskId, "mark shipped"), false);
+    }
+    if (options.noCommit === true) {
+        const git = await readGitInfo(cwd);
+        if (git.dirty === true) {
+            log.warn("Uncommitted changes left in place (--no-commit); pushing committed history only.");
+        }
+    }
+    else {
+        const message = await resolveShipCommitMessage({
             cwd,
-            taskFile,
-            skipPr: options.noPr === true,
+            taskId,
+            title: meta.title,
+            provided: options.message,
+            nonInteractive,
         });
-        if (!prResult.ok) {
-            log.error("TASK left In Progress — fix push/MR, then rerun task ship.");
+        await commitDirtyWorkingTree(cwd, message, false);
+    }
+    const remoteExists = await gitRemoteBranchExists(cwd, remote, gitCtx.taskBranch);
+    const ahead = remoteExists
+        ? await gitCommitsAhead(cwd, `${remote}/${gitCtx.taskBranch}`, "HEAD")
+        : 1;
+    const git = await readGitInfo(cwd);
+    const stillDirty = git.dirty === true;
+    if (ahead === 0 && !stillDirty) {
+        log.blank();
+        log.info(`Nothing to ship (working tree clean, PR ${prRefLabel(prCtx.number)} up to date).`);
+        return;
+    }
+    try {
+        await gitPush(cwd, remote, gitCtx.taskBranch, false);
+        log.ok(`Pushed ${gitCtx.taskBranch} → ${remote}`);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        log.error(describePushFailure(msg));
+        process.exitCode = 1;
+        return;
+    }
+    const sha = (await gitHeadCommit(cwd, true)) ?? "HEAD";
+    log.blank();
+    log.ok(`Updated existing PR ${prRefLabel(prCtx.number)} (pushed ${sha}) — CI re-running`);
+    if (prCtx.url)
+        log.info(`  ${dim("MR/PR")}     ${prCtx.url}`);
+}
+/** State 3: the previous PR is merged — start a new PR cycle (guarded). */
+async function runNewCycleFromShip(ctx) {
+    const { taskId, prCtx, dryRun, nonInteractive, options } = ctx;
+    if (!dryRun && options.newCycle !== true && options.allowOpenMr !== true) {
+        if (nonInteractive) {
+            log.error(`PR ${prRefLabel(prCtx.number)} is merged. Starting a NEW PR cycle requires --new-cycle in non-interactive mode.`);
             process.exitCode = 1;
             return;
         }
-        if (prResult.mergeRequestUrl) {
-            log.info(`  ${dim("MR/PR")}     ${prResult.mergeRequestUrl}`);
+        const ok = await askYesNo({
+            message: "This starts a NEW PR cycle after merge. Continue?",
+            nonInteractive: false,
+            defaultValue: false,
+        });
+        if (!ok) {
+            log.info(`Aborted. Use ${cyan("vibeops task add")} for unrelated work, or rerun with ${cyan("--new-cycle")}.`);
+            return;
         }
     }
-    else {
-        log.info(dim("No Git Context — push/MR skipped."));
+    await runPostMergeNewCycle(taskId, {
+        dryRun,
+        cwd: options.cwd,
+        noPr: options.noPr,
+        noIntegrate: options.noIntegrate,
+        recreateBranch: options.recreateBranch,
+        skipLlm: options.skipLlm,
+        allowOpenMr: options.allowOpenMr,
+    });
+}
+/** State/PR mismatch: Status is Shipped but no open/merged PR was found. */
+function runMismatchHint(ctx) {
+    log.warn(`${ctx.taskId} is Shipped but no open or merged PR was found for its branch.`);
+    log.info("The PR was likely merged and the branch synced/deleted.");
+    log.info(`Next: start new work with ${cyan("vibeops task add")}, or run ${cyan("vibeops status")} to re-check.`);
+}
+export async function taskShipCommand(taskRef, options = {}) {
+    const cwd = resolve(options.cwd ?? process.cwd());
+    const paths = projectPaths(cwd);
+    const dryRun = options.dryRun === true;
+    const nonInteractive = options.nonInteractive === true || !isInteractiveSession();
+    const resolved = await resolveShipTarget(paths, cwd, taskRef);
+    if (resolved === null) {
+        log.error(taskNotFoundMessage(taskRef));
+        process.exitCode = 1;
+        return;
+    }
+    const { taskId, taskFile } = resolved;
+    const meta = await readTaskFile(taskFile);
+    const body = await readText(taskFile);
+    const relFile = relPath(cwd, taskFile);
+    const prCtx = await detectShipPrState(cwd, taskFile);
+    const action = resolveShipAction(prCtx.state, meta.status);
+    log.info(bold(`vibeops task ship ${taskId}`));
+    log.info(`  ${dim("file")}  ${relFile}`);
+    if (prCtx.state !== "none") {
+        log.info(`  ${dim("PR")}    ${prRefLabel(prCtx.number)} (${prCtx.state})`);
     }
     log.blank();
-    log.info(`Next: ${cyan("vibeops task merge")} (or merge in the host UI), then ${cyan("vibeops task sync")}`);
+    const ctx = {
+        cwd,
+        taskId,
+        taskFile,
+        meta,
+        body,
+        relFile,
+        prCtx,
+        dryRun,
+        nonInteractive,
+        options,
+    };
+    switch (action) {
+        case "update-open":
+            await runUpdateOpenPr(ctx);
+            return;
+        case "new-cycle":
+            await runNewCycleFromShip(ctx);
+            return;
+        case "mismatch":
+            runMismatchHint(ctx);
+            return;
+        case "first":
+        default:
+            await runFirstShip(ctx);
+            return;
+    }
 }

package/dist/lib/inquirer-helpers.js

@@ -1,5 +1,9 @@
 import { checkbox, confirm, input, select } from "@inquirer/prompts";
 export const OTHER_LABEL = "Other";
+/** True when both stdin and stdout are TTYs (safe to show interactive prompts). */
+export function isInteractiveSession() {
+    return Boolean(process.stdin.isTTY) && Boolean(process.stdout.isTTY);
+}
 function isOther(value) {
     return value === OTHER_LABEL;
 }

package/dist/lib/pr-create.js

@@ -157,8 +157,13 @@ export async function findMergeRequestByBranches(opts) {
         return null;
     }
 }
-function prRefFromUrl(url) {
+/** Extract the numeric PR/MR id from a host URL (e.g. `#42`), or `null`. */
+export function prNumberFromUrl(url) {
+    if (typeof url !== "string")
+        return null;
     const trimmed = url.trim();
+    if (trimmed.length === 0)
+        return null;
     const pullMatch = /\/pull\/(\d+)/i.exec(trimmed);
     if (pullMatch)
         return pullMatch[1];
@@ -167,7 +172,10 @@ function prRefFromUrl(url) {
         return mrMatch[1];
     if (/^\d+$/.test(trimmed))
         return trimmed;
-    return trimmed;
+    return null;
+}
+function prRefFromUrl(url) {
+    return prNumberFromUrl(url) ?? url.trim();
 }
 export async function getMergeRequestState(cwd, host, url) {
     const ref = prRefFromUrl(url);

package/dist/lib/resolve-task.js

@@ -1,4 +1,4 @@
-import { findTaskFile, loadActionableTasks, pickActiveTask, pickInProgressTask, } from "./task.js";
+import { findTaskFile, loadActionableTasks, pickActiveTask, pickInProgressTask, pickLatestShippedTask, } from "./task.js";
 export function normalizeTaskRef(ref) {
     const t = ref.trim();
     if (/^task-/i.test(t) && !/^TASK-/i.test(t)) {
@@ -26,6 +26,36 @@ export async function resolveTask(paths, cwd, taskRef) {
     }
     return null;
 }
+/**
+ * Resolve the TASK that `ship` should act on. Unlike {@link resolveTask}, this
+ * also matches an already-Shipped TASK so state-aware ship (update open PR /
+ * new PR cycle) can re-run on it.
+ * Order: explicit ref → In Progress → active `task/*` branch → latest Shipped.
+ */
+export async function resolveShipTarget(paths, cwd, taskRef) {
+    const trimmed = taskRef?.trim();
+    if (trimmed !== undefined && trimmed.length > 0) {
+        const taskId = normalizeTaskRef(trimmed);
+        const taskFile = await findTaskFile(paths.docsTasks, taskId);
+        if (taskFile === null)
+            return null;
+        return { taskId, taskFile };
+    }
+    const tasks = await loadActionableTasks(paths.docsTasks);
+    const inProgress = pickInProgressTask(tasks);
+    if (inProgress !== null) {
+        return { taskId: inProgress.id, taskFile: inProgress.filePath };
+    }
+    const onBranch = await pickActiveTask(paths.docsTasks, cwd);
+    if (onBranch !== null) {
+        return { taskId: onBranch.id, taskFile: onBranch.filePath };
+    }
+    const shipped = pickLatestShippedTask(tasks);
+    if (shipped !== null) {
+        return { taskId: shipped.id, taskFile: shipped.filePath };
+    }
+    return null;
+}
 export function taskNotFoundMessage(taskRef) {
     if (taskRef?.trim()) {
         return `TASK not found: ${normalizeTaskRef(taskRef)}. Check docs/tasks/.`;

package/dist/lib/task-commit-msg.js

@@ -0,0 +1,80 @@
+import { readConfig } from "./config.js";
+import { gitDiffNameOnly, listWorkingTreeRelPaths } from "./git.js";
+import { anyLlmProviderAvailable, llmCompleteText } from "./llm-complete.js";
+import { getLlmPreferenceFromConfig } from "./llm-preference.js";
+import { askInput, isInteractiveSession } from "./inquirer-helpers.js";
+import { dim, log } from "./logger.js";
+import { featCommitMessageFor, taskScopedCommitMessage } from "./task-git-commit.js";
+async function changedPathsForMessage(cwd) {
+    const working = await listWorkingTreeRelPaths(cwd);
+    if (working.length > 0)
+        return working;
+    return gitDiffNameOnly(cwd);
+}
+/** Ask the LLM for a one-line conventional-commit subject from the changed files. */
+export async function generateCommitSubjectWithLlm(cwd, taskId, title) {
+    const files = await changedPathsForMessage(cwd);
+    const fileList = files.slice(0, 40).join("\n") || "(no file changes detected)";
+    const messages = [
+        {
+            role: "system",
+            content: "Write a single Conventional Commit subject line (under 72 chars) for the change. " +
+                "Reply with ONLY the subject line — no scope, no body, no quotes, no code fences. " +
+                "Pick the type from feat, fix, docs, refactor, test, chore.",
+        },
+        {
+            role: "user",
+            content: [
+                `TASK: ${taskId} — ${title}`,
+                "",
+                "Changed files:",
+                fileList,
+            ].join("\n"),
+        },
+    ];
+    try {
+        const config = await readConfig(cwd);
+        const preference = getLlmPreferenceFromConfig(config);
+        const { text } = await llmCompleteText(messages, { cwd, preference });
+        const line = text
+            .split("\n")
+            .map((l) => l.trim())
+            .find((l) => l.length > 0);
+        if (line === undefined)
+            return null;
+        return line.replace(/^["'`]+|["'`]+$/g, "").trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Resolve the commit subject for a ship, always TASK-id-scoped:
+ * 1. explicit `--message`, 2. LLM from diff (when a provider is connected),
+ * 3. interactive prompt, 4. TASK-title fallback.
+ */
+export async function resolveShipCommitMessage(opts) {
+    const provided = opts.provided?.trim();
+    if (provided !== undefined && provided.length > 0) {
+        return taskScopedCommitMessage(opts.taskId, provided);
+    }
+    if (await anyLlmProviderAvailable(opts.cwd)) {
+        const subject = await generateCommitSubjectWithLlm(opts.cwd, opts.taskId, opts.title);
+        if (subject !== null && subject.length > 0) {
+            const msg = taskScopedCommitMessage(opts.taskId, subject);
+            log.info(dim(`  commit message (LLM): ${msg}`));
+            return msg;
+        }
+    }
+    if (!opts.nonInteractive && isInteractiveSession()) {
+        const typed = await askInput({
+            message: `Commit message for ${opts.taskId}`,
+            nonInteractive: false,
+            default: opts.title,
+        });
+        if (typed.trim().length > 0) {
+            return taskScopedCommitMessage(opts.taskId, typed);
+        }
+    }
+    return featCommitMessageFor(opts.taskId, opts.title);
+}

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

@@ -64,21 +64,29 @@ export async function resolveOpenTaskMergeRequest(cwd, taskFile) {
         return legacy;
     return null;
 }
-/** MR lifecycle for hints, sync, and status — prefers host branch lookup. */
-export async function getTaskMergeRequestLifecycle(cwd, taskFile) {
+/**
+ * Single source of truth for a TASK's PR/MR lifecycle and URL.
+ * Resolution order: open branch lookup → merged branch lookup → legacy TASK URL.
+ * `ship` keys its state machine off the returned `state`.
+ */
+export async function resolveTaskMergeRequestLifecycle(cwd, taskFile) {
     const ctx = await readTaskGitContext(taskFile);
     if (ctx === null)
-        return "none";
+        return { state: "none", url: null, host: null };
     const open = await resolveFromBranches(cwd, ctx, "open");
     if (open !== null)
-        return "open";
+        return { state: "open", url: open.url, host: open.host };
     const merged = await resolveFromBranches(cwd, ctx, "merged");
     if (merged !== null)
-        return "merged";
+        return { state: "merged", url: merged.url, host: merged.host };
     const legacy = await resolveFromTaskFileUrl(cwd, ctx);
     if (legacy !== null)
-        return legacy.state;
-    return "none";
+        return { state: legacy.state, url: legacy.url, host: legacy.host };
+    return { state: "none", url: null, host: null };
+}
+/** MR lifecycle for hints, sync, and status — prefers host branch lookup. */
+export async function getTaskMergeRequestLifecycle(cwd, taskFile) {
+    return (await resolveTaskMergeRequestLifecycle(cwd, taskFile)).state;
 }
 /** @deprecated Use {@link getTaskMergeRequestLifecycle} or {@link resolveOpenTaskMergeRequest}. */
 export async function getMergeRequestStateForTask(cwd, taskFile) {

package/dist/lib/task-git-commit.js

@@ -7,6 +7,30 @@ export function featCommitMessageFor(taskId, title) {
 export function docsCommitMessageFor(taskId, suffix) {
     return `docs(${taskId.toLowerCase()}): ${suffix}`;
 }
+const CONVENTIONAL_COMMIT_RE = /^([a-z]+)(?:\(([^)]*)\))?(!)?:\s*(.+)$/is;
+/**
+ * Normalize a raw commit message so it carries the TASK id as the conventional
+ * commit scope (git-safety rule: `feat(task-001): …`).
+ *
+ * - `"fix: handle null"`            → `fix(task-001): handle null`
+ * - `"fix(login): handle null"`     → `fix(task-001): handle null` (scope rewritten)
+ * - `"handle null"`                 → `feat(task-001): handle null` (defaultType)
+ * - already-scoped correct messages are returned unchanged.
+ */
+export function taskScopedCommitMessage(taskId, rawMessage, defaultType = "feat") {
+    const scope = taskId.toLowerCase();
+    const msg = rawMessage.trim().replace(/\s+/g, " ");
+    if (msg.length === 0)
+        return `${defaultType}(${scope}): ${taskId}`;
+    const m = CONVENTIONAL_COMMIT_RE.exec(msg);
+    if (m) {
+        const type = m[1].toLowerCase();
+        const bang = m[3] ?? "";
+        const subject = m[4].trim();
+        return `${type}(${scope})${bang}: ${subject}`;
+    }
+    return `${defaultType}(${scope}): ${msg}`;
+}
 /** Commit all committable dirty paths; returns whether a commit was created. */
 export async function commitDirtyWorkingTree(cwd, message, dryRun) {
     const git = await readGitInfo(cwd);

package/dist/lib/task-new-cycle.js

@@ -0,0 +1,186 @@
+import { resolve } from "node:path";
+import { readText } from "./filesystem.js";
+import { listWorkingTreeRelPaths } from "./git.js";
+import { bold, cyan, dim, green, log, yellow } from "./logger.js";
+import { projectPaths } from "./paths.js";
+import { prNumberFromUrl } from "./pr-create.js";
+import { relPath } from "./task-context.js";
+import { commitDirtyWorkingTree, docsCommitMessageFor, featCommitMessageFor, } from "./task-git-commit.js";
+import { finishTaskWithPullRequest } from "./task-push-pr.js";
+import { applyTaskShipMemory, llmCompleteTaskReship, writeTaskResultSections, } from "./task-ship-llm.js";
+import { assertMergeRequestNotOpen, ensureTaskBranchForReship, integrateIntegrationIntoTaskBranch, loadGitConfigForReship, prepareGitContextForReship, refreshGitContextBaseCommit, resolveReshipTarget, } from "./task-reship.js";
+import { hasNonEmptySection, parseTaskFilename, readGitContext } from "./task.js";
+import { prRefLabel } from "./task-ship-state.js";
+async function commitReshipMetadata(opts) {
+    if (opts.dryRun) {
+        log.info(dim("  would commit new-cycle metadata (Status stays Shipped)"));
+        return;
+    }
+    const committed = await commitDirtyWorkingTree(opts.cwd, docsCommitMessageFor(opts.taskId, "new PR cycle metadata"), false);
+    if (!committed) {
+        log.info(dim("No new-cycle metadata commit (Git Context already on disk)."));
+    }
+}
+/**
+ * Start a NEW PR cycle for an already-Shipped TASK whose previous PR was merged
+ * (the former `task reship` behavior). Carries uncommitted work onto the task
+ * branch, integrates the integration branch, and opens a fresh MR/PR.
+ */
+export async function runPostMergeNewCycle(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 ship ${taskId} — new PR cycle`));
+    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";
+    const updateOpenMr = options.allowOpenMr === true;
+    if (!dryRun && !(await assertMergeRequestNotOpen(cwd, taskFile, updateOpenMr))) {
+        process.exitCode = 1;
+        return;
+    }
+    const branchOk = await ensureTaskBranchForReship({
+        cwd,
+        taskFile,
+        gitCtx: initialCtx,
+        integrationBranch,
+        remote,
+        recreateBranch: options.recreateBranch === true,
+        dryRun,
+    });
+    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:"));
+        if (updateOpenMr) {
+            log.info("  · feat commit, push, update open MR/PR (unless --no-pr)");
+        }
+        else {
+            log.info("  · feat commit + metadata, then push once and open a NEW MR/PR (unless --no-pr)");
+        }
+        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.info(`Nothing to do — ${taskId} is merged with no new changes. Create a new TASK for new work (${cyan("vibeops task add")}).`);
+        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;
+    }
+    if (updateOpenMr) {
+        log.info(dim("Updating open MR/PR (--allow-open-mr)."));
+    }
+    else {
+        gitCtx = await refreshGitContextBaseCommit(taskFile, gitCtx, cwd);
+        gitCtx = await prepareGitContextForReship(cwd, taskFile, gitCtx);
+        await commitReshipMetadata({
+            cwd,
+            taskFile,
+            taskId: parts.id,
+            dryRun: false,
+        });
+    }
+    const prResult = await finishTaskWithPullRequest({
+        cwd,
+        taskFile,
+        skipPr: options.noPr === true,
+        forceNewMergeRequest: !updateOpenMr,
+    });
+    if (!prResult.ok) {
+        log.error("New PR cycle failed — fix push/MR, then rerun `vibeops task ship --new-cycle`.");
+        process.exitCode = 1;
+        return;
+    }
+    log.blank();
+    const ref = prRefLabel(prNumberFromUrl(prResult.mergeRequestUrl));
+    if (prResult.mergeRequestUrl) {
+        log.ok(`Started new PR cycle → PR ${ref}`);
+        log.info(`  ${dim("MR/PR")}     ${prResult.mergeRequestUrl}`);
+    }
+    else {
+        log.ok("Started new PR cycle (branch pushed; create the MR/PR manually).");
+    }
+    log.info(`Next: ${cyan("vibeops task merge")} (or merge in the host UI), then ${cyan("vibeops task sync")}`);
+}

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

@@ -0,0 +1,39 @@
+import { prNumberFromUrl } from "./pr-create.js";
+import { resolveTaskMergeRequestLifecycle } from "./task-effective-status.js";
+/**
+ * Single entry point for `ship` to learn the current PR/MR state of a TASK.
+ * Wraps {@link resolveTaskMergeRequestLifecycle} and extracts the PR number.
+ */
+export async function detectShipPrState(cwd, taskFile) {
+    const lifecycle = await resolveTaskMergeRequestLifecycle(cwd, taskFile);
+    const state = lifecycle.state === "open"
+        ? "open"
+        : lifecycle.state === "merged"
+            ? "merged"
+            : lifecycle.state === "closed"
+                ? "closed"
+                : "none";
+    return {
+        state,
+        url: lifecycle.url,
+        number: prNumberFromUrl(lifecycle.url),
+    };
+}
+/**
+ * Map (PR state, TASK status) → the `ship` action. Pure so it is unit-testable.
+ * - open PR            → update the existing PR (state 2)
+ * - merged PR          → start a new PR cycle (state 3, guarded)
+ * - no/closed PR + In Progress → first submit (state 1)
+ * - no/closed PR + Shipped     → status/PR mismatch (resync hint)
+ */
+export function resolveShipAction(prState, taskStatus) {
+    if (prState === "open")
+        return "update-open";
+    if (prState === "merged")
+        return "new-cycle";
+    return taskStatus === "shipped" ? "mismatch" : "first";
+}
+/** Format the PR reference for output (`#42` or `the PR`). */
+export function prRefLabel(prNumber) {
+    return prNumber !== null ? `#${prNumber}` : "the PR";
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodtek/vibeops",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "Minimal CLI rails for Cursor-based TASK-driven vibe coding.",
   "type": "module",
   "packageManager": "pnpm@9.15.9",
@@ -35,7 +35,8 @@
     "build": "tsc -p tsconfig.json",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "start": "node dist/cli.js",
-    "smoke": "pnpm typecheck && pnpm build && node scripts/smoke.mjs",
+    "test": "pnpm build && node --test \"tests/*.test.mjs\"",
+    "smoke": "pnpm typecheck && pnpm build && node --test \"tests/*.test.mjs\" && node scripts/smoke.mjs",
     "clean": "rm -rf dist",
     "prepack": "pnpm clean && pnpm build",
     "publish:dry": "pnpm publish --dry-run --no-git-checks"

package/templates/clients/claude/CLAUDE.md

@@ -2,5 +2,5 @@
 
 - Work from `docs/tasks/TASK-NNN-*.md` only.
 - One TASK at a time.
-- Fill **Result** and **Test Result** before telling the human to run `vibeops task ship TASK-NNN` (or `task reship` for Shipped follow-up).
+- Fill **Result** and **Test Result** before telling the human to run `vibeops task ship TASK-NNN`. `ship` is state-aware: re-running before merge updates the open PR; after merge use `vibeops task ship --new-cycle`.
 - Do not merge to integration or main unless the human runs `vibeops task merge` / `task sync` / `task release`.

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

@@ -8,4 +8,4 @@ alwaysApply: true
 - Use branch pattern `task/*` from `vibeops task add`.
 - Include TASK id in commits: `feat(task-nnn): …`.
 - No force-push to shared branches.
-- Run `vibeops task ship`, `task reship`, `task merge`, `task sync` when the human asks — do not merge locally in the IDE unless requested.
+- Run `vibeops task ship`, `task merge`, `task sync` when the human asks — do not merge locally in the IDE unless requested. (`ship` is state-aware: it updates an open PR or, with `--new-cycle`, starts a new PR cycle after merge.)

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

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

package/templates/core/AGENTS.md

@@ -8,12 +8,14 @@
 vibeops task add
 # Plan / build in your agent (@docs/tasks/TASK-NNN-*.md)
 
-vibeops task ship
+vibeops task ship           # state-aware: new PR / update open PR / new cycle
 vibeops task merge          # CLI or host UI
 vibeops task sync           # optional — branch cleanup only
 
-# Same TASK follow-up (after merge):
-vibeops task reship TASK-NNN
+# Same TASK, before merge — just re-run ship to update the open PR:
+vibeops task ship -m "address review"
+# Same TASK, after merge — start a new PR cycle:
+vibeops task ship --new-cycle
 vibeops task merge
 ```
 
@@ -26,16 +28,17 @@ Only two values in `## Status`:
 | Status | Meaning |
 |--------|---------|
 | **In Progress** | Active slice (`task add`) |
-| **Shipped** | Submitted (`task ship` or `task reship`) |
+| **Shipped** | Submitted (`task ship`) |
 
 Merge and sync do **not** change the TASK file.
 
 ```bash
-vibeops llm connect   # optional — task add / ship / reship
+vibeops llm connect   # optional — task add / ship
 ```
 
 ## Rules
 
 - One **In Progress** TASK at a time; **Shipped** does not block `task add`.
-- Fill **Result** and **Test Result** before `vibeops task ship` (or before `task reship` for follow-ups).
-- Agents do not run `task merge`, `task sync`, or `task reship` unless the human asks.
+- Fill **Result** and **Test Result** before `vibeops task ship` (warned, not blocked, when updating an open PR).
+- `ship` is state-aware: re-run it to update an open PR; after merge it needs `--new-cycle` (or a confirm) to start a new PR cycle. `task reship` still works as a deprecated alias for `task ship --new-cycle`.
+- Agents do not run `task merge` or `task sync` unless the human asks.

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

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