@goodtek/vibeops 2.0.0 → 2.1.1

package/dist/lib/task-context.js

@@ -1,20 +1,18 @@
 import { relative } from "node:path";
 import { gitBranchExists, readGitInfo } from "./git.js";
+import { isMergeRequestMerged, taskNeedsSync } from "./task-effective-status.js";
 import { readGitContext } from "./task.js";
 import { isOnTaskBranch, loadActionableTasks, pickActiveTask, pickInProgressTask, } from "./task.js";
-/** TASK that blocks `task add` — in progress, in review, or open on current task branch. */
+/** Only **In Progress** blocks the next `task add`. */
 export async function findBlockingTask(paths, cwd) {
     const tasks = await loadActionableTasks(paths.docsTasks);
     const inProgress = pickInProgressTask(tasks);
     if (inProgress !== null)
         return inProgress;
-    const review = tasks.find((t) => t.status === "review");
-    if (review !== undefined)
-        return review;
     const git = await readGitInfo(cwd);
     if (git.isRepo && typeof git.branch === "string" && git.branch.startsWith("task/")) {
         for (const t of tasks) {
-            if (t.status === "done")
+            if (t.status !== "in_progress")
                 continue;
             const ctx = await readGitContext(t.filePath);
             if (isOnTaskBranch(git.branch, ctx))
@@ -24,7 +22,17 @@ export async function findBlockingTask(paths, cwd) {
     return null;
 }
 export async function pickFocusTask(paths, cwd) {
-    return pickActiveTask(paths.docsTasks, cwd);
+    const active = await pickActiveTask(paths.docsTasks, cwd);
+    if (active !== null)
+        return active;
+    const shipped = (await loadActionableTasks(paths.docsTasks))
+        .filter((t) => t.status === "shipped")
+        .sort((a, b) => {
+        const na = Number.parseInt(/^TASK-(\d+)$/i.exec(a.id)?.[1] ?? "0", 10);
+        const nb = Number.parseInt(/^TASK-(\d+)$/i.exec(b.id)?.[1] ?? "0", 10);
+        return nb - na;
+    });
+    return shipped[0] ?? null;
 }
 export function relPath(cwd, filePath) {
     const r = relative(cwd, filePath).replace(/\\/g, "/");
@@ -35,11 +43,14 @@ export function computeNextHint(input) {
         return "init";
     if (input.focus === null)
         return "task-add";
-    if (input.focus.status === "done") {
-        return input.onTaskBranch === true ? "task-sync" : "task-add";
-    }
-    if (input.focus.status === "review") {
-        return input.hasMergeRequest ? "task-merge" : "task-ship";
+    if (input.focus.status === "shipped") {
+        if (input.needsSync)
+            return "task-sync";
+        if (input.hasMergeRequest && !input.mergeRequestMerged)
+            return "task-merge";
+        if (input.hasLocalChanges && input.onTaskBranch === true)
+            return "task-reship";
+        return "task-add";
     }
     if (!input.resultFilled || !input.testFilled) {
         return input.onTaskBranch === true ? "cursor-implement" : "cursor-plan";
@@ -54,14 +65,18 @@ export function hintToText(hint, cwd, task) {
             return "Run `vibeops task add` to start the next slice.";
         case "task-ship":
             return task ? `Run \`vibeops task ship ${task.id}\`.` : "Run `vibeops task ship`.";
+        case "task-reship":
+            return task
+                ? `Follow-up on ${task.id}? Edit on task branch, then \`vibeops task reship ${task.id}\`.`
+                : "Run `vibeops task reship TASK-NNN` for a Shipped follow-up.";
         case "task-merge":
             return task
-                ? `Run \`vibeops task merge ${task.id}\`, then task sync.`
-                : "Run `vibeops task merge` after the MR is ready.";
+                ? `Merge the MR (UI or \`vibeops task merge ${task.id}\`), then optional task sync.`
+                : "Merge the MR on the host or with `vibeops task merge`.";
         case "task-sync":
             return task
-                ? `MR merged? Run \`vibeops task sync ${task.id}\`, then task add.`
-                : "Run `vibeops task sync` after merging the MR.";
+                ? `Run \`vibeops task sync ${task.id}\` to delete task branches, then task add.`
+                : "Run `vibeops task sync` to delete task branches after merge.";
         case "cursor-plan":
             return task
                 ? `In Cursor Ask: @${relPath(cwd, task.filePath)} — refine Scope / AC.`
@@ -81,3 +96,4 @@ export async function taskBranchExistsFor(cwd, task) {
         return false;
     return gitBranchExists(cwd, ctx.taskBranch);
 }
+export { isMergeRequestMerged, taskNeedsSync };

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

@@ -0,0 +1,62 @@
+import { GitConfigError, requireGitConfig } from "./git-config.js";
+import { detectGitHost } from "./git-host.js";
+import { gitBranchExists, gitRemoteBranchExists, gitRemoteUrl, } from "./git.js";
+import { getMergeRequestState, probeMergeRequestCli } from "./pr-create.js";
+import { readGitContext } from "./task.js";
+/** MR state for a TASK file, or `null` when there is no MR URL or host CLI is unavailable. */
+export async function getMergeRequestStateForTask(cwd, taskFile) {
+    const ctx = await readGitContext(taskFile);
+    const url = ctx?.mergeRequestUrl?.trim();
+    if (url === undefined || url.length === 0)
+        return null;
+    let host;
+    try {
+        const gitCfg = await requireGitConfig(cwd);
+        const remoteUrl = await gitRemoteUrl(cwd, gitCfg.remote);
+        host =
+            remoteUrl !== null && detectGitHost(remoteUrl) !== null
+                ? detectGitHost(remoteUrl)
+                : gitCfg.host;
+    }
+    catch (e) {
+        if (e instanceof GitConfigError)
+            return null;
+        throw e;
+    }
+    if (!(await probeMergeRequestCli(host)))
+        return null;
+    return getMergeRequestState(cwd, host, url);
+}
+export async function isMergeRequestMerged(cwd, task) {
+    if (task.status !== "shipped")
+        return false;
+    const state = await getMergeRequestStateForTask(cwd, task.filePath);
+    return state === "merged";
+}
+/**
+ * After ship: optional `task sync` when MR is merged (or no MR) but `task/*` still exists.
+ */
+export async function taskNeedsSync(cwd, task) {
+    if (task.status !== "shipped")
+        return false;
+    const ctx = await readGitContext(task.filePath);
+    if (ctx === null)
+        return false;
+    const mrUrl = ctx.mergeRequestUrl?.trim();
+    if (mrUrl !== undefined && mrUrl.length > 0) {
+        const state = await getMergeRequestStateForTask(cwd, task.filePath);
+        if (state !== "merged")
+            return false;
+    }
+    if (await gitBranchExists(cwd, ctx.taskBranch))
+        return true;
+    try {
+        const gitCfg = await requireGitConfig(cwd);
+        return gitRemoteBranchExists(cwd, gitCfg.remote, ctx.taskBranch);
+    }
+    catch (e) {
+        if (e instanceof GitConfigError)
+            return false;
+        throw e;
+    }
+}

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

@@ -1,5 +1,5 @@
 import { readGitInfo } from "./git.js";
-import { isOnTaskBranch, loadActionableTasks, pickLatestReviewTask, readGitContext, } from "./task.js";
+import { isOnTaskBranch, loadActionableTasks, pickLatestShippedTask, readGitContext, } from "./task.js";
 import { resolveTask } from "./resolve-task.js";
 /** Resolve TASK + task branch for ship / merge / sync. */
 export async function resolveLifecycleTarget(paths, cwd, taskRef) {
@@ -27,15 +27,15 @@ export async function resolveLifecycleTarget(paths, cwd, taskRef) {
             }
         }
     }
-    const review = pickLatestReviewTask(await loadActionableTasks(paths.docsTasks));
-    if (review === null)
+    const shipped = pickLatestShippedTask(await loadActionableTasks(paths.docsTasks));
+    if (shipped === null)
         return null;
-    const ctx = await readGitContext(review.filePath);
+    const ctx = await readGitContext(shipped.filePath);
     if (ctx === null)
         return null;
     return {
-        taskId: review.id,
+        taskId: shipped.id,
         taskBranch: ctx.taskBranch,
-        taskFile: review.filePath,
+        taskFile: shipped.filePath,
     };
 }

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

@@ -59,7 +59,8 @@ 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)) {
+    if (isExistingMergeRequestUrl(gitCtx.mergeRequestUrl) &&
+        opts.forceNewMergeRequest !== true) {
         log.info(dim(`Merge request already recorded: ${gitCtx.mergeRequestUrl}`));
         return { ok: true, mergeRequestUrl: gitCtx.mergeRequestUrl, pushed: true };
     }

package/dist/lib/task-reship.js

@@ -0,0 +1,192 @@
+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 { normalizeTaskRef } from "./resolve-task.js";
+import { archiveMergeRequestForReship, findTaskFile, loadActionableTasks, pickLatestShippedTask, readGitContext, readTaskFile, upsertGitContext, } from "./task.js";
+export async function resolveReshipTarget(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 shipped = pickLatestShippedTask(await loadActionableTasks(paths.docsTasks));
+        if (shipped === null) {
+            log.error(reshipNotFoundMessage(undefined));
+            return null;
+        }
+        taskId = shipped.id;
+        taskFile = shipped.filePath;
+    }
+    if (taskFile === null) {
+        log.error(reshipNotFoundMessage(taskRef));
+        return null;
+    }
+    const meta = await readTaskFile(taskFile);
+    if (meta.status !== "shipped") {
+        log.error(`${taskId} is ${meta.status === "in_progress" ? "In Progress" : meta.status} — use \`vibeops task ship\` for first submit.`);
+        return null;
+    }
+    const gitCtx = await readGitContext(taskFile);
+    if (gitCtx === null) {
+        log.error(`No Git Context on ${taskId}. Cannot reship.`);
+        return null;
+    }
+    return { taskId, taskFile, meta, gitCtx };
+}
+export function reshipNotFoundMessage(taskRef) {
+    if (taskRef?.trim()) {
+        return `Shipped TASK not found: ${normalizeTaskRef(taskRef)}. Check docs/tasks/.`;
+    }
+    return "No Shipped TASK found. Pass `vibeops task reship TASK-NNN`.";
+}
+/** Checkout or recreate the task branch without changing TASK Status. */
+export async function ensureTaskBranchForReship(opts) {
+    const cwd = resolve(opts.cwd);
+    const { taskBranch } = opts.gitCtx;
+    const git = await readGitInfo(cwd);
+    if (!git.isRepo) {
+        log.error("Not a git repository.");
+        return false;
+    }
+    if (git.dirty === true && !opts.allowDirty) {
+        const gov = await gitGovernanceOnlyDirty(cwd);
+        if (!gov.onlyGovernance) {
+            log.error("Working tree is dirty. Commit or stash, or rerun with --allow-dirty.");
+            return false;
+        }
+        log.warn("Only governance paths are dirty — proceeding.");
+    }
+    const localExists = await gitBranchExists(cwd, taskBranch);
+    const remoteExists = await gitRemoteBranchExists(cwd, opts.remote, taskBranch);
+    if (opts.dryRun) {
+        if (localExists) {
+            log.info(dim(`  would git switch ${taskBranch}`));
+        }
+        else if (opts.recreateBranch) {
+            log.info(dim(`  would recreate ${taskBranch} from ${opts.integrationBranch}`));
+        }
+        else {
+            log.error(`Local branch ${taskBranch} missing. Rerun with --recreate-branch.`);
+            return false;
+        }
+        return true;
+    }
+    if (localExists) {
+        await gitCheckout(cwd, taskBranch);
+        log.ok(`On ${taskBranch}`);
+        return true;
+    }
+    if (!opts.recreateBranch) {
+        if (remoteExists) {
+            log.error(`Local ${taskBranch} missing. Fetch/checkout the branch or rerun with --recreate-branch.`);
+        }
+        else {
+            log.error(`Branch ${taskBranch} not found locally or on ${opts.remote}. Use --recreate-branch.`);
+        }
+        return false;
+    }
+    const ok = await gitSwitchToBranch(cwd, opts.integrationBranch, opts.remote);
+    if (!ok) {
+        log.error(`Integration branch "${opts.integrationBranch}" not found.`);
+        return false;
+    }
+    if (await gitRemoteBranchExists(cwd, opts.remote, opts.integrationBranch)) {
+        try {
+            await gitPullFastForwardOnly(cwd, opts.remote, opts.integrationBranch);
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            log.error(`Could not update ${opts.integrationBranch}: ${msg}`);
+            return false;
+        }
+    }
+    const head = await gitHeadCommit(cwd);
+    if (head === null || head.length === 0) {
+        log.error("Integration branch has no commits.");
+        return false;
+    }
+    await gitCheckoutNewBranch(cwd, taskBranch, opts.integrationBranch);
+    await upsertGitContext(opts.taskFile, {
+        ...opts.gitCtx,
+        baseBranch: opts.integrationBranch,
+        baseCommit: head,
+    });
+    log.ok(`Recreated ${taskBranch} from ${opts.integrationBranch}`);
+    return true;
+}
+/** Merge latest integration into the current task branch. */
+export async function integrateIntegrationIntoTaskBranch(opts) {
+    const cwd = resolve(opts.cwd);
+    if (opts.dryRun) {
+        log.info(dim(`  would git fetch ${opts.remote} && git merge ${opts.remote}/${opts.integrationBranch}`));
+        return true;
+    }
+    try {
+        await gitFetchRemote(cwd, opts.remote);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        log.warn(`git fetch failed (${msg}). Continuing with local refs.`);
+    }
+    if (!(await gitRemoteBranchExists(cwd, opts.remote, opts.integrationBranch))) {
+        log.warn(`No ${opts.remote}/${opts.integrationBranch} — skipped integrate.`);
+        return true;
+    }
+    try {
+        await gitMergeRemoteBranch(cwd, opts.remote, opts.integrationBranch);
+        log.ok(`Merged ${opts.remote}/${opts.integrationBranch} into task branch`);
+        return true;
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        if (await gitMergeInProgress(cwd)) {
+            const conflicts = await listUnmergedRelPaths(cwd);
+            log.error(`Merge conflict with ${opts.integrationBranch}. Resolve, commit, then rerun.`);
+            if (conflicts.length > 0) {
+                log.info(dim(`Conflicts: ${conflicts.slice(0, 8).join(", ")}`));
+            }
+        }
+        else {
+            log.error(`Could not merge ${opts.integrationBranch}: ${msg}`);
+        }
+        return false;
+    }
+}
+export async function assertMergeRequestNotOpen(cwd, taskFile, allowOpenMr) {
+    if (allowOpenMr)
+        return true;
+    const state = await getMergeRequestStateForTask(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.");
+    return false;
+}
+export async function refreshGitContextBaseCommit(taskFile, gitCtx, cwd) {
+    const head = await gitHeadCommit(cwd);
+    if (head === null || head.length === 0)
+        return gitCtx;
+    return { ...gitCtx, baseCommit: head };
+}
+export async function prepareGitContextForReship(taskFile, gitCtx) {
+    const archived = archiveMergeRequestForReship(gitCtx);
+    await upsertGitContext(taskFile, archived);
+    return archived;
+}
+export async function loadGitConfigForReship(cwd) {
+    try {
+        const cfg = await requireGitConfig(cwd);
+        return { remote: cfg.remote, integrationBranch: cfg.integrationBranch };
+    }
+    catch (e) {
+        if (e instanceof GitConfigError) {
+            log.error(e.message);
+            return null;
+        }
+        throw e;
+    }
+}

package/dist/lib/task-scaffold.js

@@ -28,7 +28,7 @@ export function buildMinimalTaskMarkdown(draft) {
 
 ## Status
 
-${statusDisplay("planned")}
+${statusDisplay("in_progress")}
 
 ## Goal
 

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

@@ -31,7 +31,7 @@ export async function llmCompleteTaskShip(params) {
     const messages = [
         {
             role: "system",
-            content: `You ship a VibeOps TASK for review. Reply with JSON only:
+            content: `You ship a VibeOps TASK (Status → Shipped). Reply with JSON only:
 {
   "result": "markdown for TASK Result section — facts, paths, commands",
   "testResult": "markdown for Test Result — commands and outcomes",
@@ -91,7 +91,88 @@ Be factual. Do not invent files not in the diff.`,
                 : null,
             logLine: typeof parsed.logLine === "string" && parsed.logLine.trim().length > 0
                 ? parsed.logLine.trim()
-                : `${params.taskId} shipped for review.`,
+                : `${params.taskId} shipped.`,
+            provider,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export async function llmCompleteTaskReship(params) {
+    const git = await readGitInfo(params.cwd);
+    let diffSummary = "";
+    if (git.isRepo) {
+        const names = await gitDiffNameOnly(params.cwd);
+        diffSummary = names.slice(0, 40).join("\n") || "(no diff vs HEAD index yet)";
+    }
+    const paths = projectPaths(params.cwd);
+    const currentState = (await readOptional(join(paths.root, PROJECT_MEMORY_FILES.currentState))) ?? "";
+    const existingResult = readSection(params.taskBody, "Result");
+    const existingTest = readSection(params.taskBody, "Test Result");
+    const messages = [
+        {
+            role: "system",
+            content: `You reship a follow-up on an already Shipped VibeOps TASK. Reply with JSON only:
+{
+  "result": "full Result section — preserve prior facts and add a ## Follow-up subsection for this pass",
+  "testResult": "full Test Result for this follow-up — commands and outcomes",
+  "currentStateMarkdown": "full replacement for docs/project/05-current-state.md OR null to skip",
+  "decisionsAppend": "markdown bullets to append under ## Decisions OR null",
+  "architectureUpdate": "full replacement for 03-architecture.md OR null if unchanged",
+  "logLine": "one line for docs/logs/YYYY-MM-DD.md"
+}
+Be factual. Do not invent files not in the diff.`,
+        },
+        {
+            role: "user",
+            content: [
+                `TASK follow-up reship: ${params.taskId} — ${params.taskTitle}`,
+                `File: ${params.taskFileRel}`,
+                "",
+                "Existing Result:",
+                existingResult || "(empty)",
+                "",
+                "Existing Test Result:",
+                existingTest || "(empty)",
+                "",
+                "Changed paths (working tree / HEAD):",
+                diffSummary,
+                "",
+                "Current project state excerpt:",
+                currentState.slice(0, 2000),
+            ].join("\n"),
+        },
+    ];
+    try {
+        const config = await readConfig(params.cwd);
+        const preference = getLlmPreferenceFromConfig(config);
+        const { text: raw, provider } = await llmCompleteJson(messages, {
+            cwd: params.cwd,
+            preference,
+        });
+        const parsed = JSON.parse(extractJsonObject(raw));
+        return {
+            result: typeof parsed.result === "string" && parsed.result.trim().length > 0
+                ? parsed.result.trim()
+                : `${existingResult}\n\n## Follow-up\n\nReship ${params.taskId}.`,
+            testResult: typeof parsed.testResult === "string" && parsed.testResult.trim().length > 0
+                ? parsed.testResult.trim()
+                : existingTest || "Follow-up verification required.",
+            currentStateMarkdown: typeof parsed.currentStateMarkdown === "string" &&
+                parsed.currentStateMarkdown.trim().length > 0
+                ? parsed.currentStateMarkdown.trim()
+                : null,
+            decisionsAppend: typeof parsed.decisionsAppend === "string" && parsed.decisionsAppend.trim().length > 0
+                ? parsed.decisionsAppend.trim()
+                : null,
+            architectureUpdate: typeof parsed.architectureUpdate === "string" &&
+                parsed.architectureUpdate.trim().length > 0
+                ? parsed.architectureUpdate.trim()
+                : null,
+            logLine: typeof parsed.logLine === "string" && parsed.logLine.trim().length > 0
+                ? parsed.logLine.trim()
+                : `${params.taskId} reship follow-up.`,
             provider,
         };
     }
@@ -147,7 +228,7 @@ export async function fallbackResultSections(cwd, taskId, taskFile) {
     const body = await readText(taskFile);
     const goal = readSection(body, "Goal").slice(0, 200);
     const result = [
-        `Shipped ${taskId} for review.`,
+        `Shipped ${taskId}.`,
         goal.length > 0 ? `Goal: ${goal}` : "",
         names.length > 0 ? `Paths: ${names.slice(0, 15).join(", ")}` : "",
     ]

package/dist/lib/task-start.js

@@ -81,7 +81,7 @@ export async function startTaskBranch(opts) {
     log.info(`  ${dim("task branch")}  ${cyan(taskBranch)}`);
     if (branchExists) {
         await gitCheckout(cwd, taskBranch);
-        if (meta.status === "planned") {
+        if (meta.status !== "shipped") {
             await updateInlineStatus(taskFile, "in_progress");
         }
         if (existingCtx === null) {