@goodtek/vibeops 2.2.1 → 2.4.0

package/dist/lib/task-del.js

@@ -0,0 +1,193 @@
+import { resolve } from "node:path";
+import { deleteFile } from "./filesystem.js";
+import { GitConfigError, requireGitConfig } from "./git-config.js";
+import { mergeRequestLabel } from "./git-host.js";
+import { gitBranchExists, gitDeleteBranch, gitDeleteRemoteBranch, gitGovernanceOnlyDirty, gitRemoteBranchExists, gitSwitchToBranch, readGitInfo, } from "./git.js";
+import { dim, log } from "./logger.js";
+import { closeMergeRequest, findMergeRequestByBranches, probeMergeRequestCli, } from "./pr-create.js";
+import { normalizeTaskRef } from "./resolve-task.js";
+import { getTaskMergeRequestLifecycle, resolveGitHostForCwd } from "./task-effective-status.js";
+import { findTaskFile, loadActionableTasks, pickInProgressTask, readGitContext, readTaskFile, } from "./task.js";
+export async function resolveDelTarget(paths, cwd, taskRef) {
+    const trimmed = taskRef?.trim();
+    let taskId;
+    let taskFile;
+    if (trimmed !== undefined && trimmed.length > 0) {
+        taskId = normalizeTaskRef(trimmed);
+        taskFile = await findTaskFile(paths.docsTasks, taskId);
+    }
+    else {
+        const inProgress = pickInProgressTask(await loadActionableTasks(paths.docsTasks));
+        if (inProgress === null) {
+            return null;
+        }
+        taskId = inProgress.id;
+        taskFile = inProgress.filePath;
+    }
+    if (taskFile === null) {
+        return null;
+    }
+    const meta = await readTaskFile(taskFile);
+    const ctx = await readGitContext(taskFile);
+    if (ctx === null) {
+        log.error(`No Git Context on ${taskId}. Cannot delete.`);
+        return null;
+    }
+    return { taskId, taskFile, meta, taskBranch: ctx.taskBranch };
+}
+export function taskDelNotFoundMessage(taskRef) {
+    if (taskRef?.trim()) {
+        return `TASK not found: ${normalizeTaskRef(taskRef)}. Check docs/tasks/.`;
+    }
+    return "No In Progress TASK found. Pass `vibeops task del TASK-NNN`.";
+}
+export async function assertTaskDeletable(cwd, target) {
+    const lifecycle = await getTaskMergeRequestLifecycle(cwd, target.taskFile);
+    if (lifecycle === "merged") {
+        return {
+            ok: false,
+            reason: `${target.taskId} is merged into integration — task del is not allowed. ` +
+                "Revert on develop if needed, or keep the TASK file as history.",
+        };
+    }
+    return { ok: true };
+}
+export async function assertWorkingTreeForDel(cwd, allowDirty) {
+    const git = await readGitInfo(cwd);
+    if (git.dirty !== true)
+        return true;
+    const gov = await gitGovernanceOnlyDirty(cwd);
+    if (gov.onlyGovernance)
+        return true;
+    if (allowDirty) {
+        log.warn("Uncommitted changes remain in the working tree after delete.");
+        return true;
+    }
+    log.error("Working tree is dirty. Commit, stash, restore, or rerun with --force to discard uncommitted work.");
+    return false;
+}
+function isProtectedBranch(name, integration, production) {
+    return name === integration || name === production || name === "main" || name === "master";
+}
+export async function deleteTaskBranches(opts) {
+    const cwd = resolve(opts.cwd);
+    if (opts.dryRun) {
+        if (await gitBranchExists(cwd, opts.taskBranch)) {
+            log.info(dim(`  would git branch -D ${opts.taskBranch}`));
+        }
+        if (opts.noRemoteDelete !== true &&
+            (await gitRemoteBranchExists(cwd, opts.remote, opts.taskBranch))) {
+            log.info(dim(`  would git push ${opts.remote} --delete ${opts.taskBranch}`));
+        }
+        return true;
+    }
+    const git = await readGitInfo(cwd);
+    if (git.branch === opts.taskBranch) {
+        const switched = await gitSwitchToBranch(cwd, opts.integrationBranch, opts.remote);
+        if (!switched) {
+            log.error(`Integration branch "${opts.integrationBranch}" not found.`);
+            return false;
+        }
+        log.ok(`On ${opts.integrationBranch}`);
+    }
+    if (await gitBranchExists(cwd, opts.taskBranch)) {
+        try {
+            await gitDeleteBranch(cwd, opts.taskBranch, { force: true });
+            log.ok(`Deleted local branch ${opts.taskBranch}`);
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            log.error(`Could not delete local ${opts.taskBranch}: ${msg}`);
+            return false;
+        }
+    }
+    else {
+        log.info(dim(`Local branch ${opts.taskBranch} not found — skipped.`));
+    }
+    if (opts.noRemoteDelete !== true &&
+        (await gitRemoteBranchExists(cwd, opts.remote, opts.taskBranch))) {
+        try {
+            await gitDeleteRemoteBranch(cwd, opts.remote, opts.taskBranch);
+            log.ok(`Deleted ${opts.remote}/${opts.taskBranch}`);
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            log.warn(`Could not delete remote ${opts.taskBranch}: ${msg}`);
+        }
+    }
+    else if (opts.noRemoteDelete === true) {
+        log.info(dim("Remote branch delete skipped (--no-remote-delete)."));
+    }
+    return true;
+}
+export async function closeOpenTaskMergeRequestIfNeeded(opts) {
+    if (opts.skipClose) {
+        log.info(dim("Open MR/PR close skipped (--no-close-mr)."));
+        return true;
+    }
+    const lifecycle = await getTaskMergeRequestLifecycle(opts.cwd, opts.taskFile);
+    if (lifecycle !== "open")
+        return true;
+    const host = await resolveGitHostForCwd(opts.cwd);
+    if (host === null) {
+        log.warn("Could not resolve Git host — close the MR/PR manually.");
+        return true;
+    }
+    const open = await findMergeRequestByBranches({
+        cwd: opts.cwd,
+        host,
+        headBranch: opts.taskBranch,
+        baseBranch: opts.baseBranch,
+        state: "open",
+    });
+    if (open === null)
+        return true;
+    const label = mergeRequestLabel(host);
+    if (!(await probeMergeRequestCli(host))) {
+        log.warn(`Open ${label}: ${open.url} — close it manually before deleting the branch.`);
+        return true;
+    }
+    try {
+        await closeMergeRequest({ cwd: opts.cwd, host, url: open.url, dryRun: opts.dryRun });
+        if (!opts.dryRun)
+            log.ok(`Closed ${label}`);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        log.warn(`Could not close ${label}: ${msg}`);
+        log.info(dim(`Close manually: ${open.url}`));
+    }
+    return true;
+}
+export async function deleteTaskMarkdown(taskFile, dryRun) {
+    if (dryRun) {
+        log.info(dim(`  would delete ${taskFile}`));
+        return;
+    }
+    await deleteFile(taskFile);
+    log.ok(`Deleted TASK file`);
+}
+export async function loadGitConfigForDel(cwd) {
+    try {
+        const cfg = await requireGitConfig(cwd);
+        return {
+            remote: cfg.remote,
+            integrationBranch: cfg.integrationBranch,
+            productionBranch: cfg.productionBranch,
+        };
+    }
+    catch (e) {
+        if (e instanceof GitConfigError) {
+            log.error(e.message);
+            return null;
+        }
+        throw e;
+    }
+}
+export function validateTaskBranchForDel(taskBranch, integrationBranch, productionBranch) {
+    if (isProtectedBranch(taskBranch, integrationBranch, productionBranch)) {
+        log.error(`Refusing to delete protected branch: ${taskBranch}`);
+        return false;
+    }
+    return true;
+}

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.2.1",
+  "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`.