@goodtek/vibeops 2.1.1 → 2.1.3

package/CHANGELOG.md

@@ -4,14 +4,22 @@ All notable changes to VibeOps are documented here.
 
 ## Unreleased
 
-## 2.1.1 - 2026-06-08
+## 2.1.3 - 2026-06-08
 
 ### Changed
 
-- **Docs:** living markdown, templates, and Cursor rules aligned with 2.1 lifecycle (`task reship`, two-status model, sync does not edit TASK md).
-- **`task sync` CLI help:** description no longer says "mark Done".
+- **MR/PR resolution:** `task merge`, `status`, and `task sync` resolve the open PR by **`(taskBranch, baseBranch)`** via `gh` / `glab` (host is source of truth).
+- **`task ship` / `task reship`:** no longer write `Merge Request` or `Pushed At` into TASK md after PR creation — **single push, clean working tree**, CI once per PR.
+- **`task reship`:** archives the current open PR URL into `Previous Merge Requests` (from host lookup) in the reship metadata commit.
+- **Legacy TASK files** that still have `Merge Request:` in Git Context remain supported as a fallback.
 
-## 2.1.0 - 2026-06-03
+## 2.1.2 - 2026-06-08
+
+### Changed
+
+- **`task ship`** / **`task reship`**: commit ship/reship metadata **before** push and MR/PR creation so the branch is pushed once (avoids duplicate `pull_request` CI runs on `opened` + `synchronize`).
+
+## 2.1.1 - 2026-06-08
 
 ### Added
 
@@ -19,6 +27,13 @@ All notable changes to VibeOps are documented here.
 
 ### Changed
 
+- **Docs:** living markdown, templates, and Cursor rules aligned with 2.1 lifecycle (`task reship`, two-status model, sync does not edit TASK md).
+- **`task sync` CLI help:** description no longer says "mark Done".
+
+## 2.1.0 - 2026-06-03
+
+### Changed
+
 - **TASK md status:** only **In Progress** → **Shipped** (`task ship`). Merge (CLI/UI) and **`task sync`** do not edit the TASK file.
 - **`task sync`**: Git cleanup only (integration pull, delete `task/*` branches).
 - **`task add`**: blocks only another **In Progress** TASK (not **Shipped**).

package/README.md

@@ -106,7 +106,7 @@ pnpm install && pnpm build && pnpm smoke
 
 - **Init** records branch policy in `.vibeops.json` (`integrationBranch`, `productionBranch`, `host`).
 - **`task add`**: `task/<slug>` from **integration** (e.g. `develop`).
-- **`task ship`**: commit → push → MR/PR → Status **Shipped** on task branch.
+- **`task ship`**: commit implementation + ship metadata (Status **Shipped**) → push once → MR/PR (URL on host; `task merge` resolves by branch).
 - **`task reship`**: Shipped TASK only; integrates `develop`; opens **new** PR (archives previous MR in Git Context).
 - **`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).

package/dist/commands/status.js

@@ -8,7 +8,7 @@ import { bold, cyan, dim, green, log, yellow } from "../lib/logger.js";
 import { projectPaths } from "../lib/paths.js";
 import { VERSION } from "../version.js";
 import { computeNextHint, hintToText, listInProgressTasks, pickFocusTask, relPath, taskBranchExistsFor, } from "../lib/task-context.js";
-import { isMergeRequestMerged, taskNeedsSync } from "../lib/task-effective-status.js";
+import { hasOpenTaskMergeRequest, isMergeRequestMerged, resolveTaskMergeRequestUrl, taskNeedsSync, } from "../lib/task-effective-status.js";
 import { countTasks, hasNonEmptySection, isOnTaskBranch, loadActionableTasks, readGitContext, statusDisplay, } from "../lib/task.js";
 import { summarizeGoal } from "../lib/task-summary.js";
 async function buildReport(cwd) {
@@ -42,7 +42,7 @@ async function buildReport(cwd) {
         testFilled = hasNonEmptySection(body, "Test Result");
         const ctx = await readGitContext(focus.filePath);
         taskBranch = ctx?.taskBranch ?? null;
-        mergeRequestUrl = ctx?.mergeRequestUrl ?? null;
+        mergeRequestUrl = await resolveTaskMergeRequestUrl(cwd, focus.filePath);
         onTaskBranch = isOnTaskBranch(git.branch, ctx);
         branchExists = await taskBranchExistsFor(cwd, focus);
         mergeRequestMerged = await isMergeRequestMerged(cwd, focus);
@@ -67,7 +67,9 @@ async function buildReport(cwd) {
         resultFilled,
         testFilled,
         onTaskBranch,
-        hasMergeRequest: typeof mergeRequestUrl === "string" && mergeRequestUrl.length > 0,
+        hasMergeRequest: focus !== null
+            ? await hasOpenTaskMergeRequest(cwd, focus.filePath)
+            : false,
         mergeRequestMerged,
         needsSync,
         hasLocalChanges: git.dirty === true,

package/dist/commands/task-merge.js

@@ -8,6 +8,7 @@ import { taskNotFoundMessage } from "../lib/resolve-task.js";
 import { getMergeRequestState, mergeMergeRequest, probeMergeRequestCli, } from "../lib/pr-create.js";
 import { relPath } from "../lib/task-context.js";
 import { resolveLifecycleTarget } from "../lib/task-lifecycle-target.js";
+import { resolveOpenTaskMergeRequest } from "../lib/task-effective-status.js";
 import { readGitContext } from "../lib/task.js";
 function resolveMergeMethod(opts) {
     if (opts.rebase === true)
@@ -49,26 +50,26 @@ export async function taskMergeCommand(taskRef, options = {}) {
         process.exitCode = 1;
         return;
     }
-    if (!ctx.mergeRequestUrl) {
-        if (dryRun) {
-            log.info(dim(`would merge ${ctx.taskBranch} → ${ctx.baseBranch} after MR exists (run task ship)`));
-            log.blank();
-            log.info(`Next: ${cyan("vibeops task sync")}`);
-            return;
-        }
-        log.error("No Merge Request URL on TASK — run task ship first.");
+    const resolvedMr = dryRun
+        ? null
+        : await resolveOpenTaskMergeRequest(cwd, target.taskFile);
+    if (!dryRun && resolvedMr === null) {
+        log.error(`No open MR/PR for ${ctx.taskBranch} → ${ctx.baseBranch}. Run task ship or task reship first.`);
         process.exitCode = 1;
         return;
     }
+    const mergeRequestUrl = resolvedMr?.url ??
+        `(dry-run: would resolve open MR for ${ctx.taskBranch} → ${ctx.baseBranch})`;
     const remoteUrl = await gitRemoteUrl(cwd, gitCfg.remote);
-    const host = remoteUrl !== null && detectGitHost(remoteUrl) !== null
-        ? detectGitHost(remoteUrl)
-        : gitCfg.host;
+    const host = resolvedMr?.host ??
+        (remoteUrl !== null && detectGitHost(remoteUrl) !== null
+            ? detectGitHost(remoteUrl)
+            : gitCfg.host);
     const method = resolveMergeMethod(options);
     const label = mergeRequestLabel(host);
     log.info(bold(`vibeops task merge ${target.taskId}`));
     log.info(`  ${dim("file")}       ${relPath(cwd, target.taskFile)}`);
-    log.info(`  ${dim("MR/PR")}      ${ctx.mergeRequestUrl}`);
+    log.info(`  ${dim("MR/PR")}      ${mergeRequestUrl}`);
     log.info(`  ${dim("target")}     ${ctx.baseBranch} (${gitCfg.integrationBranch})`);
     log.info(`  ${dim("method")}     ${method}`);
     log.blank();
@@ -76,7 +77,7 @@ export async function taskMergeCommand(taskRef, options = {}) {
         await mergeMergeRequest({
             cwd,
             host,
-            url: ctx.mergeRequestUrl,
+            url: mergeRequestUrl,
             method,
             dryRun: true,
         });
@@ -84,7 +85,7 @@ export async function taskMergeCommand(taskRef, options = {}) {
         log.info(`Next: ${cyan("vibeops task sync")}`);
         return;
     }
-    const state = await getMergeRequestState(cwd, host, ctx.mergeRequestUrl);
+    const state = await getMergeRequestState(cwd, host, mergeRequestUrl);
     if (state === "merged") {
         log.ok(`${label} already merged.`);
         log.blank();
@@ -100,7 +101,7 @@ export async function taskMergeCommand(taskRef, options = {}) {
             return;
         }
         try {
-            await mergeMergeRequest({ cwd, host, url: ctx.mergeRequestUrl, method });
+            await mergeMergeRequest({ cwd, host, url: mergeRequestUrl, method });
             log.ok(`${label} merged into ${ctx.baseBranch}.`);
         }
         catch (e) {
@@ -119,7 +120,7 @@ export async function taskMergeCommand(taskRef, options = {}) {
     else {
         log.warn(`Could not read ${label} state — attempting merge anyway.`);
         try {
-            await mergeMergeRequest({ cwd, host, url: ctx.mergeRequestUrl, method });
+            await mergeMergeRequest({ cwd, host, url: mergeRequestUrl, method });
             log.ok(`${label} merge command completed.`);
         }
         catch (e) {

package/dist/commands/task-reship.js

@@ -3,36 +3,21 @@ 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, pushBranch, } from "../lib/task-git-commit.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, upsertGitContext, } from "../lib/task.js";
+import { hasNonEmptySection, parseTaskFilename, readGitContext, } from "../lib/task.js";
 import { listWorkingTreeRelPaths } from "../lib/git.js";
-async function commitReshipMetadataAndPush(opts) {
+async function commitReshipMetadata(opts) {
     if (opts.dryRun) {
         log.info(dim("  would commit reship metadata (Status stays Shipped)"));
-        if (opts.push !== null) {
-            log.info(dim(`  would git push ${opts.push.remote} ${opts.push.branch} (reship metadata)`));
-        }
-        return true;
+        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)."));
     }
-    if (opts.push === null)
-        return true;
-    try {
-        await pushBranch(opts.cwd, opts.push.remote, opts.push.branch, false);
-        log.ok(`Pushed reship metadata → ${opts.push.remote}/${opts.push.branch}`);
-        return true;
-    }
-    catch (e) {
-        const msg = e instanceof Error ? e.message : String(e);
-        log.error(`Reship metadata push failed: ${msg}`);
-        return false;
-    }
 }
 export async function taskReshipCommand(taskRef, options = {}) {
     const cwd = resolve(options.cwd ?? process.cwd());
@@ -129,8 +114,7 @@ export async function taskReshipCommand(taskRef, options = {}) {
     log.blank();
     if (dryRun) {
         log.info(bold("dry-run — would also:"));
-        log.info("  · archive prior MR URL; open new MR/PR (unless --no-pr)");
-        log.info("  · feat commit + reship metadata push");
+        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;
@@ -155,8 +139,13 @@ export async function taskReshipCommand(taskRef, options = {}) {
         return;
     }
     gitCtx = await refreshGitContextBaseCommit(taskFile, gitCtx, cwd);
-    gitCtx = await prepareGitContextForReship(taskFile, gitCtx);
-    await upsertGitContext(taskFile, gitCtx);
+    gitCtx = await prepareGitContextForReship(cwd, taskFile, gitCtx);
+    await commitReshipMetadata({
+        cwd,
+        taskFile,
+        taskId: parts.id,
+        dryRun: false,
+    });
     const prResult = await finishTaskWithPullRequest({
         cwd,
         taskFile,
@@ -171,22 +160,6 @@ export async function taskReshipCommand(taskRef, options = {}) {
     if (prResult.mergeRequestUrl) {
         log.info(`  ${dim("MR/PR")}     ${prResult.mergeRequestUrl}`);
     }
-    const gitCtxAfter = await readGitContext(taskFile);
-    let pushTarget = null;
-    if (gitCtxAfter !== null && gitCfg !== null) {
-        pushTarget = { remote: gitCfg.remote, branch: gitCtxAfter.taskBranch };
-    }
-    const pushed = await commitReshipMetadataAndPush({
-        cwd,
-        taskFile,
-        taskId: parts.id,
-        dryRun: false,
-        push: pushTarget,
-    });
-    if (!pushed) {
-        process.exitCode = 1;
-        return;
-    }
     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,42 +1,24 @@
 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 { relPath } from "../lib/task-context.js";
-import { commitDirtyWorkingTree, docsCommitMessageFor, featCommitMessageFor, pushBranch, } from "../lib/task-git-commit.js";
+import { commitDirtyWorkingTree, docsCommitMessageFor, featCommitMessageFor, } 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";
 import { hasNonEmptySection, parseTaskFilename, readGitContext, readTaskFile, updateInlineStatus, } from "../lib/task.js";
-async function commitShipMetadataAndPush(opts) {
+async function commitShipMetadata(opts) {
     if (opts.dryRun) {
         log.info(dim("  would set Status → Shipped"));
         log.info(dim("  would commit ship metadata"));
-        if (opts.push !== null) {
-            log.info(dim(`  would git push ${opts.push.remote} ${opts.push.branch} (ship metadata)`));
-        }
-        return true;
+        return;
     }
     await updateInlineStatus(opts.taskFile, "shipped");
     log.ok("Status → Shipped");
     const committed = await commitDirtyWorkingTree(opts.cwd, docsCommitMessageFor(opts.taskId, "mark shipped"), false);
     if (!committed) {
         log.warn("No file changes for ship metadata commit — check TASK Status on the remote branch.");
-        return true;
-    }
-    if (opts.push === null)
-        return true;
-    try {
-        await pushBranch(opts.cwd, opts.push.remote, opts.push.branch, false);
-        log.ok(`Pushed ship metadata → ${opts.push.remote}/${opts.push.branch}`);
-        return true;
-    }
-    catch (e) {
-        const msg = e instanceof Error ? e.message : String(e);
-        log.error(`Ship metadata push failed: ${msg}`);
-        log.info(dim(`Fix auth/remote, then: git push ${opts.push.remote} ${opts.push.branch}`));
-        return false;
     }
 }
 export async function taskShipCommand(taskRef, options = {}) {
@@ -104,24 +86,20 @@ export async function taskShipCommand(taskRef, options = {}) {
         if (!resultOk || !testOk) {
             log.info("  · LLM fill Result / Test Result + patch docs/project/*");
         }
-        log.info("  · commit implementation, push task branch, open MR/PR (unless --no-pr)");
-        log.info("  · Status → Shipped; commit metadata; push again");
-        await finishTaskWithPullRequest({
+        log.info("  · commit implementation + ship metadata (Status → Shipped)");
+        log.info("  · push task branch once, open MR/PR (unless --no-pr)");
+        const partsDry = parseTaskFilename(taskFile);
+        await commitShipMetadata({
             cwd,
             taskFile,
+            taskId: partsDry.id,
             dryRun: true,
-            skipPr: options.noPr === true,
         });
-        const gitCtxDry = await readGitContext(taskFile);
-        const gitCfgDry = gitCtxDry !== null ? await requireGitConfig(cwd).catch(() => null) : null;
-        await commitShipMetadataAndPush({
+        await finishTaskWithPullRequest({
             cwd,
             taskFile,
-            taskId,
             dryRun: true,
-            push: gitCtxDry !== null && gitCfgDry !== null
-                ? { remote: gitCfgDry.remote, branch: gitCtxDry.taskBranch }
-                : null,
+            skipPr: options.noPr === true,
         });
         return;
     }
@@ -129,6 +107,12 @@ export async function taskShipCommand(taskRef, options = {}) {
     await commitDirtyWorkingTree(cwd, featCommitMessageFor(parts.id, meta.title), false);
     const gitCtx = await readGitContext(taskFile);
     if (gitCtx !== null) {
+        await commitShipMetadata({
+            cwd,
+            taskFile,
+            taskId: parts.id,
+            dryRun: false,
+        });
         const prResult = await finishTaskWithPullRequest({
             cwd,
             taskFile,
@@ -146,30 +130,6 @@ export async function taskShipCommand(taskRef, options = {}) {
     else {
         log.info(dim("No Git Context — push/MR skipped."));
     }
-    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("Ship metadata push failed — fix manually, then merge the MR.");
-        process.exitCode = 1;
-        return;
-    }
     log.blank();
     log.info(`Next: ${cyan("vibeops task merge")} (or merge in the host UI), then ${cyan("vibeops task sync")}`);
 }

package/dist/commands/task-sync.js

@@ -7,9 +7,9 @@ import { probeMergeRequestCli } from "../lib/pr-create.js";
 import { projectPaths } from "../lib/paths.js";
 import { taskNotFoundMessage } from "../lib/resolve-task.js";
 import { relPath } from "../lib/task-context.js";
-import { getMergeRequestStateForTask, isMergeRequestMerged, } from "../lib/task-effective-status.js";
+import { getTaskMergeRequestLifecycle, isMergeRequestMerged, } from "../lib/task-effective-status.js";
 import { resolveLifecycleTarget } from "../lib/task-lifecycle-target.js";
-import { readGitContext, readTaskFile } from "../lib/task.js";
+import { readTaskFile } from "../lib/task.js";
 function isProtectedBranch(name, integration, production) {
     return name === integration || name === production || name === "main" || name === "master";
 }
@@ -42,7 +42,6 @@ export async function taskSyncCommand(taskRef, options = {}) {
     }
     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;
@@ -55,18 +54,18 @@ export async function taskSyncCommand(taskRef, options = {}) {
     log.info(`  ${dim("note")}        ${dim("Git cleanup only — TASK md stays Shipped")}`);
     log.blank();
     const meta = await readTaskFile(taskFile);
-    if (ctx?.mergeRequestUrl && !dryRun) {
-        const state = await getMergeRequestStateForTask(cwd, taskFile);
-        if (state !== null) {
+    if (!dryRun) {
+        const lifecycle = await getTaskMergeRequestLifecycle(cwd, taskFile);
+        if (lifecycle !== "none") {
             const remoteUrl = await gitRemoteUrl(cwd, remote);
             const host = remoteUrl !== null && detectGitHost(remoteUrl) !== null
                 ? detectGitHost(remoteUrl)
                 : gitCfg.host;
             const label = mergeRequestLabel(host);
-            if (state === "open") {
+            if (lifecycle === "open") {
                 log.warn(`${yellow(label)} still open — merge with task merge or the host UI before sync.`);
             }
-            else if (state === "merged") {
+            else if (lifecycle === "merged") {
                 log.ok(`${label} merged.`);
             }
         }

package/dist/lib/pr-create.js

@@ -64,6 +64,99 @@ export async function probeMergeRequestCli(host) {
         return false;
     }
 }
+function normalizeGhMergeRequestState(raw) {
+    const state = raw.trim().toUpperCase();
+    if (state === "MERGED")
+        return "merged";
+    if (state === "OPEN")
+        return "open";
+    if (state === "CLOSED")
+        return "closed";
+    return "unknown";
+}
+function normalizeGlabMergeRequestState(raw) {
+    const state = raw.trim().toLowerCase();
+    if (state === "merged")
+        return "merged";
+    if (state === "opened" || state === "open")
+        return "open";
+    if (state === "closed")
+        return "closed";
+    return "unknown";
+}
+async function ghFindMergeRequestByBranches(opts) {
+    const state = opts.state ?? "open";
+    const { stdout } = await execFileAsync("gh", [
+        "pr",
+        "list",
+        "--head",
+        opts.headBranch,
+        "--base",
+        opts.baseBranch,
+        "--state",
+        state,
+        "--limit",
+        "1",
+        "--json",
+        "url,state",
+    ], { cwd: opts.cwd, maxBuffer: 1024 * 1024 });
+    const trimmed = stdout.trim();
+    if (trimmed.length === 0 || trimmed === "[]")
+        return null;
+    const rows = JSON.parse(trimmed);
+    const row = rows[0];
+    if (row?.url === undefined || row.url.length === 0)
+        return null;
+    return {
+        url: row.url,
+        state: normalizeGhMergeRequestState(row.state ?? ""),
+    };
+}
+async function glabFindMergeRequestByBranches(opts) {
+    const state = opts.state ?? "open";
+    const glabState = state === "open" ? "opened" : state === "merged" ? "merged" : state === "closed" ? "closed" : "all";
+    const { stdout } = await execFileAsync("glab", [
+        "mr",
+        "list",
+        "--source-branch",
+        opts.headBranch,
+        "--target-branch",
+        opts.baseBranch,
+        "-S",
+        glabState,
+        "-P",
+        "1",
+        "--output",
+        "json",
+        "web_url,state",
+    ], { cwd: opts.cwd, maxBuffer: 1024 * 1024 });
+    const trimmed = stdout.trim();
+    if (trimmed.length === 0 || trimmed === "[]")
+        return null;
+    const rows = JSON.parse(trimmed);
+    const row = rows[0];
+    const url = row?.web_url?.trim();
+    if (url === undefined || url.length === 0)
+        return null;
+    return {
+        url,
+        state: normalizeGlabMergeRequestState(row.state ?? ""),
+    };
+}
+/** Resolve MR/PR by `(headBranch, baseBranch)` — source of truth for ship/reship (no TASK URL). */
+export async function findMergeRequestByBranches(opts) {
+    try {
+        if (!(await probeMergeRequestCli(opts.host)))
+            return null;
+        if (opts.host === "gitlab") {
+            return glabFindMergeRequestByBranches(opts);
+        }
+        return ghFindMergeRequestByBranches(opts);
+    }
+    catch {
+        return null;
+    }
+}
 function prRefFromUrl(url) {
     const trimmed = url.trim();
     const pullMatch = /\/pull\/(\d+)/i.exec(trimmed);

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

@@ -1,37 +1,103 @@
 import { GitConfigError, requireGitConfig } from "./git-config.js";
 import { detectGitHost } from "./git-host.js";
 import { gitBranchExists, gitRemoteBranchExists, gitRemoteUrl, } from "./git.js";
-import { getMergeRequestState, probeMergeRequestCli } from "./pr-create.js";
+import { findMergeRequestByBranches, getMergeRequestState, probeMergeRequestCli, } from "./pr-create.js";
 import { readGitContext } from "./task.js";
-/** MR state for a TASK file, or `null` when there is no MR URL or host CLI is unavailable. */
-export async function getMergeRequestStateForTask(cwd, taskFile) {
-    const ctx = await readGitContext(taskFile);
-    const url = ctx?.mergeRequestUrl?.trim();
-    if (url === undefined || url.length === 0)
-        return null;
-    let host;
+export async function resolveGitHostForCwd(cwd) {
     try {
         const gitCfg = await requireGitConfig(cwd);
         const remoteUrl = await gitRemoteUrl(cwd, gitCfg.remote);
-        host =
-            remoteUrl !== null && detectGitHost(remoteUrl) !== null
-                ? detectGitHost(remoteUrl)
-                : gitCfg.host;
+        if (remoteUrl !== null && detectGitHost(remoteUrl) !== null) {
+            return detectGitHost(remoteUrl);
+        }
+        return gitCfg.host;
     }
     catch (e) {
         if (e instanceof GitConfigError)
             return null;
         throw e;
     }
-    if (!(await probeMergeRequestCli(host)))
+}
+async function readTaskGitContext(taskFile) {
+    return readGitContext(taskFile);
+}
+async function resolveFromBranches(cwd, ctx, state) {
+    try {
+        const host = await resolveGitHostForCwd(cwd);
+        if (host === null)
+            return null;
+        const found = await findMergeRequestByBranches({
+            cwd,
+            host,
+            headBranch: ctx.taskBranch,
+            baseBranch: ctx.baseBranch,
+            state,
+        });
+        if (found === null)
+            return null;
+        return { url: found.url, host, state: found.state, source: "branch" };
+    }
+    catch {
+        return null;
+    }
+}
+async function resolveFromTaskFileUrl(cwd, ctx) {
+    const url = ctx.mergeRequestUrl?.trim();
+    if (url === undefined || url.length === 0)
+        return null;
+    const host = await resolveGitHostForCwd(cwd);
+    if (host === null || !(await probeMergeRequestCli(host)))
         return null;
-    return getMergeRequestState(cwd, host, url);
+    const state = await getMergeRequestState(cwd, host, url);
+    return { url, host, state, source: "task-file" };
+}
+/** Open MR/PR for a TASK — branch lookup first, legacy TASK URL fallback. */
+export async function resolveOpenTaskMergeRequest(cwd, taskFile) {
+    const ctx = await readTaskGitContext(taskFile);
+    if (ctx === null)
+        return null;
+    const fromBranch = await resolveFromBranches(cwd, ctx, "open");
+    if (fromBranch !== null)
+        return fromBranch;
+    const legacy = await resolveFromTaskFileUrl(cwd, ctx);
+    if (legacy !== null && legacy.state === "open")
+        return legacy;
+    return null;
+}
+/** MR lifecycle for hints, sync, and status — prefers host branch lookup. */
+export async function getTaskMergeRequestLifecycle(cwd, taskFile) {
+    const ctx = await readTaskGitContext(taskFile);
+    if (ctx === null)
+        return "none";
+    const open = await resolveFromBranches(cwd, ctx, "open");
+    if (open !== null)
+        return "open";
+    const merged = await resolveFromBranches(cwd, ctx, "merged");
+    if (merged !== null)
+        return "merged";
+    const legacy = await resolveFromTaskFileUrl(cwd, ctx);
+    if (legacy !== null)
+        return legacy.state;
+    return "none";
+}
+/** @deprecated Use {@link getTaskMergeRequestLifecycle} or {@link resolveOpenTaskMergeRequest}. */
+export async function getMergeRequestStateForTask(cwd, taskFile) {
+    const lifecycle = await getTaskMergeRequestLifecycle(cwd, taskFile);
+    if (lifecycle === "none")
+        return null;
+    return lifecycle;
+}
+export async function hasOpenTaskMergeRequest(cwd, taskFile) {
+    return (await getTaskMergeRequestLifecycle(cwd, taskFile)) === "open";
+}
+export async function resolveTaskMergeRequestUrl(cwd, taskFile) {
+    const open = await resolveOpenTaskMergeRequest(cwd, taskFile);
+    return open?.url ?? null;
 }
 export async function isMergeRequestMerged(cwd, task) {
     if (task.status !== "shipped")
         return false;
-    const state = await getMergeRequestStateForTask(cwd, task.filePath);
-    return state === "merged";
+    return (await getTaskMergeRequestLifecycle(cwd, task.filePath)) === "merged";
 }
 /**
  * After ship: optional `task sync` when MR is merged (or no MR) but `task/*` still exists.
@@ -39,15 +105,12 @@ export async function isMergeRequestMerged(cwd, task) {
 export async function taskNeedsSync(cwd, task) {
     if (task.status !== "shipped")
         return false;
-    const ctx = await readGitContext(task.filePath);
+    const ctx = await readTaskGitContext(task.filePath);
     if (ctx === null)
         return false;
-    const mrUrl = ctx.mergeRequestUrl?.trim();
-    if (mrUrl !== undefined && mrUrl.length > 0) {
-        const state = await getMergeRequestStateForTask(cwd, task.filePath);
-        if (state !== "merged")
-            return false;
-    }
+    const lifecycle = await getTaskMergeRequestLifecycle(cwd, task.filePath);
+    if (lifecycle === "open")
+        return false;
     if (await gitBranchExists(cwd, ctx.taskBranch))
         return true;
     try {

package/dist/lib/task-push-pr.js

@@ -4,9 +4,9 @@ import { detectGitHost, mergeRequestLabel } from "./git-host.js";
 import { requireGitConfig } from "./git-config.js";
 import { gitCommitsAhead, gitDiffNameOnly, gitLogOneline, gitPush, gitRemoteUrl, readGitInfo, } from "./git.js";
 import { dim, log } from "./logger.js";
-import { createMergeRequest, probeMergeRequestCli } from "./pr-create.js";
+import { createMergeRequest, findMergeRequestByBranches, probeMergeRequestCli, } from "./pr-create.js";
 import { fallbackTaskPr, generateTaskPrWithLlm } from "./task-pr-llm.js";
-import { readGitContext, readTaskFile, upsertGitContext } from "./task.js";
+import { readGitContext, readTaskFile } from "./task.js";
 async function buildDiffSummary(cwd, gitCtx) {
     const files = await gitDiffNameOnly(cwd, `${gitCtx.baseCommit}..HEAD`);
     const commits = await gitLogOneline(cwd, `${gitCtx.baseCommit}..HEAD`);
@@ -28,12 +28,7 @@ async function buildDiffSummary(cwd, gitCtx) {
     }
     return lines.join("\n") || "(no commits since task start)";
 }
-function isExistingMergeRequestUrl(url) {
-    if (typeof url !== "string" || url.length === 0)
-        return false;
-    return url.startsWith("http://") || url.startsWith("https://");
-}
-/** Push task branch and open MR/PR (idempotent when URL already in Git Context). */
+/** Push task branch and open MR/PR. Does not write MR URL into TASK md (host is source of truth). */
 export async function finishTaskWithPullRequest(opts) {
     let gitCfg = await requireGitConfig(opts.cwd);
     const gitCtx = await readGitContext(opts.taskFile);
@@ -41,8 +36,9 @@ export async function finishTaskWithPullRequest(opts) {
         log.warn("No Git Context on TASK — push and merge request skipped.");
         return { ok: true };
     }
+    const label = mergeRequestLabel(gitCfg.host);
     if (opts.dryRun) {
-        log.info(dim(`would git push -u ${gitCfg.remote} ${gitCtx.taskBranch} and open ${mergeRequestLabel(gitCfg.host)} → ${gitCtx.baseBranch}`));
+        log.info(dim(`would git push -u ${gitCfg.remote} ${gitCtx.taskBranch} and open ${label} → ${gitCtx.baseBranch}`));
         return { ok: true, mergeRequestUrl: "(dry-run)" };
     }
     const remoteUrl = await gitRemoteUrl(opts.cwd, gitCfg.remote);
@@ -59,10 +55,18 @@ export async function finishTaskWithPullRequest(opts) {
     if (git.branch !== gitCtx.taskBranch) {
         log.warn(`Current branch is ${git.branch ?? "(detached)"}, not ${gitCtx.taskBranch}. Push may fail.`);
     }
-    if (isExistingMergeRequestUrl(gitCtx.mergeRequestUrl) &&
-        opts.forceNewMergeRequest !== true) {
-        log.info(dim(`Merge request already recorded: ${gitCtx.mergeRequestUrl}`));
-        return { ok: true, mergeRequestUrl: gitCtx.mergeRequestUrl, pushed: true };
+    if (opts.skipPr !== true && opts.forceNewMergeRequest !== true) {
+        const existing = await findMergeRequestByBranches({
+            cwd: opts.cwd,
+            host: gitCfg.host,
+            headBranch: gitCtx.taskBranch,
+            baseBranch: gitCtx.baseBranch,
+            state: "open",
+        });
+        if (existing !== null) {
+            log.info(dim(`Open ${label} already exists: ${existing.url}`));
+            return { ok: true, mergeRequestUrl: existing.url, pushed: true };
+        }
     }
     const ahead = await gitCommitsAhead(opts.cwd, gitCtx.baseCommit, "HEAD");
     if (ahead === 0) {
@@ -77,17 +81,14 @@ export async function finishTaskWithPullRequest(opts) {
         log.error(`git push failed: ${msg}`);
         return { ok: false };
     }
-    const pushedAt = new Date().toISOString();
     if (opts.skipPr === true) {
-        await upsertGitContext(opts.taskFile, { ...gitCtx, pushedAt });
         log.info(dim("Merge request creation skipped (--no-pr)."));
         return { ok: true, pushed: true };
     }
     const cliOk = await probeMergeRequestCli(gitCfg.host);
     if (!cliOk) {
         const tool = gitCfg.host === "gitlab" ? "glab" : "gh";
-        await upsertGitContext(opts.taskFile, { ...gitCtx, pushedAt });
-        log.warn(`${tool} CLI not found — create the ${mergeRequestLabel(gitCfg.host)} manually: ${gitCtx.taskBranch} → ${gitCtx.baseBranch}`);
+        log.warn(`${tool} CLI not found — create the ${label} manually: ${gitCtx.taskBranch} → ${gitCtx.baseBranch}`);
         return { ok: true, pushed: true };
     }
     const config = await readConfig(opts.cwd);
@@ -114,18 +115,13 @@ export async function finishTaskWithPullRequest(opts) {
             title: prTitle,
             body: prBody,
         });
-        log.ok(`${mergeRequestLabel(gitCfg.host)}: ${url}`);
-        await upsertGitContext(opts.taskFile, {
-            ...gitCtx,
-            mergeRequestUrl: url,
-            pushedAt,
-        });
+        log.ok(`${label}: ${url}`);
+        log.info(dim("MR/PR URL is on the host — not written to TASK md (use task merge)."));
         return { ok: true, mergeRequestUrl: url, pushed: true };
     }
     catch (e) {
         const msg = e instanceof Error ? e.message : String(e);
         log.error(`Could not create merge request: ${msg}`);
-        await upsertGitContext(opts.taskFile, { ...gitCtx, pushedAt });
         log.info(dim(`Branch was pushed. Create MR manually: ${gitCtx.taskBranch} → ${gitCtx.baseBranch}`));
         return { ok: false, pushed: true };
     }

package/dist/lib/task-reship.js

@@ -2,9 +2,10 @@ import { resolve } from "node:path";
 import { GitConfigError, requireGitConfig } from "./git-config.js";
 import { gitBranchExists, gitCheckout, gitCheckoutNewBranch, gitFetchRemote, gitGovernanceOnlyDirty, gitHeadCommit, gitMergeRemoteBranch, gitMergeInProgress, gitPullFastForwardOnly, gitRemoteBranchExists, gitSwitchToBranch, listUnmergedRelPaths, readGitInfo, } from "./git.js";
 import { dim, log } from "./logger.js";
-import { getMergeRequestStateForTask } from "./task-effective-status.js";
+import { findMergeRequestByBranches } from "./pr-create.js";
 import { normalizeTaskRef } from "./resolve-task.js";
-import { archiveMergeRequestForReship, findTaskFile, loadActionableTasks, pickLatestShippedTask, readGitContext, readTaskFile, upsertGitContext, } from "./task.js";
+import { getTaskMergeRequestLifecycle, resolveGitHostForCwd, } from "./task-effective-status.js";
+import { findTaskFile, loadActionableTasks, pickLatestShippedTask, readGitContext, readTaskFile, upsertGitContext, } from "./task.js";
 export async function resolveReshipTarget(paths, cwd, taskRef) {
     const trimmed = taskRef?.trim();
     let taskId;
@@ -160,7 +161,7 @@ export async function integrateIntegrationIntoTaskBranch(opts) {
 export async function assertMergeRequestNotOpen(cwd, taskFile, allowOpenMr) {
     if (allowOpenMr)
         return true;
-    const state = await getMergeRequestStateForTask(cwd, taskFile);
+    const state = await getTaskMergeRequestLifecycle(cwd, taskFile);
     if (state !== "open")
         return true;
     log.error("Current MR/PR is still open. Merge or close it first, or rerun with --allow-open-mr.");
@@ -172,8 +173,32 @@ export async function refreshGitContextBaseCommit(taskFile, gitCtx, cwd) {
         return gitCtx;
     return { ...gitCtx, baseCommit: head };
 }
-export async function prepareGitContextForReship(taskFile, gitCtx) {
-    const archived = archiveMergeRequestForReship(gitCtx);
+export async function prepareGitContextForReship(cwd, taskFile, gitCtx) {
+    const previous = [...(gitCtx.previousMergeRequestUrls ?? [])];
+    const host = await resolveGitHostForCwd(cwd);
+    if (host !== null) {
+        const open = await findMergeRequestByBranches({
+            cwd,
+            host,
+            headBranch: gitCtx.taskBranch,
+            baseBranch: gitCtx.baseBranch,
+            state: "open",
+        });
+        if (open !== null) {
+            previous.push(open.url);
+        }
+    }
+    const legacy = gitCtx.mergeRequestUrl?.trim();
+    if (legacy !== undefined && legacy.length > 0 && !previous.includes(legacy)) {
+        previous.push(legacy);
+    }
+    const archived = {
+        ...gitCtx,
+        previousMergeRequestUrls: previous.length > 0 ? previous : undefined,
+        mergeRequestUrl: undefined,
+        reshipCount: (gitCtx.reshipCount ?? 0) + 1,
+        lastReshipAt: new Date().toISOString(),
+    };
     await upsertGitContext(taskFile, archived);
     return archived;
 }

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@goodtek/vibeops",
-  "version": "2.1.1",
+  "version": "2.1.3",
   "description": "Minimal CLI rails for Cursor-based TASK-driven vibe coding.",
   "type": "module",
+  "packageManager": "pnpm@9.15.9",
   "author": "VibeOps contributors",
   "license": "MIT",
   "repository": {
@@ -29,6 +30,16 @@
   "engines": {
     "node": ">=20"
   },
+  "scripts": {
+    "dev": "tsx src/cli.ts",
+    "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",
+    "clean": "rm -rf dist",
+    "prepack": "pnpm clean && pnpm build",
+    "publish:dry": "pnpm publish --dry-run --no-git-checks"
+  },
   "keywords": [
     "cursor",
     "ai",
@@ -47,14 +58,5 @@
     "@types/node": "^20.14.0",
     "tsx": "^4.19.0",
     "typescript": "^5.5.4"
-  },
-  "scripts": {
-    "dev": "tsx src/cli.ts",
-    "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",
-    "clean": "rm -rf dist",
-    "publish:dry": "pnpm publish --dry-run --no-git-checks"
   }
-}
+}