@goodtek/vibeops 2.4.3 → 2.5.0

package/CHANGELOG.md

@@ -4,6 +4,26 @@ All notable changes to VibeOps are documented here.
 
 ## Unreleased
 
+## 2.5.0 - 2026-07-19
+
+### Breaking
+
+- **Removed `vibeops task reship`.** Use `vibeops task ship` (state-aware). After merge, confirm or pass `--new-cycle`. Hidden flag `ship --reship` remains as an alias for `--new-cycle`.
+
+### Changed
+
+- **`vibeops init` remote setup:** ask GitHub / GitLab / Skip, then Create or Connect. Soft-gate when `gh`/`glab` is missing (install hints, optional `brew install` with consent, or manual URL).
+- **`vibeops status`:** human output is a **Now / Next** card (focus, checklist, PR, next command); details (project, counts, LLM) move to a dim footer.
+- Shared **host CLI install/login hints** for ship / merge / release when the tool is missing.
+
+## 2.4.4 - 2026-06-25
+
+### Fixed
+
+- **`task sync`:** After merge verification passes, delete the local `task/*` branch with `-D`. Squash-merged TASK branches no longer require `--force` for cleanup.
+- **`task merge` / `task release`:** Wait for MR/PR CI to finish before calling the host merge API. GitLab no longer gets an immediate `--auto-merge=false` merge while the pipeline is still running (405). Falls back to auto-merge when needed, then polls until `merged_at` is set.
+- **`task release`:** Default merge strategy is now **merge commit** (integration → production). Use `--squash` to squash.
+
 ## 2.4.3 - 2026-06-25
 
 ### Fixed

package/README.md

@@ -15,22 +15,23 @@ VibeOps bootstraps an **agent-friendly repo**, starts numbered **TASK** files on
 | `vibeops task add` | New `TASK-NNN` file + task branch |
 | `vibeops task del` | Cancel TASK before merge (md + branch + close open MR) |
 | `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) |
 | `vibeops pull` | Fetch remote + update integration branch (e.g. develop) |
-| `vibeops status` | Briefing: TASK, Git, LLM, clients |
+| `vibeops status` | Now / Next briefing: focus TASK, Git, what to run next |
 | `vibeops llm` | Connect LLM providers (`connect` · `status` · `use`) |
 
 ## Init
 
+Interactive init asks which agents to install, Git branch policy, then **where the remote lives** (GitHub / GitLab / skip) and whether to **create** or **connect** a repository. If `gh`/`glab` is missing, init prints install hints (optional `brew install` with consent) or accepts a URL — it does not block the rest of VibeOps.
+
 ```bash
-# Interactive: pick agents (≥1), then Git
+# Interactive: pick agents (≥1), then Git + remote host
 vibeops init
 
 # Non-interactive (GitFlow: develop + main, origin required unless CI)
-vibeops init --clients cursor,claude,codex --git --initial-commit --git-policy gitflow
+vibeops init --clients cursor,claude,codex --git --initial-commit --git-policy gitflow --allow-no-remote
 
 # Re-init templates on an existing project
 vibeops init --clients cursor --yes
@@ -107,11 +108,10 @@ pnpm install && pnpm build && pnpm smoke
 
 ## Flags (common)
 
-- **`init`**: `--clients`, `--yes`, `--dry-run`, `--force`, `--git`, `--initial-commit`, `--git-policy gitflow|trunk`, `--integration-branch`, `--production-branch`, `--allow-no-remote`, `--cwd`
+- **`init`**: `--clients`, `--yes`, `--dry-run`, `--force`, `--git`, `--initial-commit`, `--git-policy gitflow|trunk`, `--integration-branch`, `--production-branch`, `--git-host github|gitlab`, `--allow-no-remote`, `--cwd`
 - **`task add`**: `--dry-run`, `--non-interactive --idea "…"`
 - **`task del`**: `--dry-run`, `--force`, `--no-remote-delete`, `--no-close-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 ship`**: `-m/--message`, `--new-cycle`, `--no-commit`, `--dry-run`, `--no-pr`, `--non-interactive`, `--allow-open-mr`, `--no-integrate`, `--recreate-branch`, `--skip-llm`
 - **`task merge`**: `--dry-run`, `--merge`, `--rebase`
 - **`task sync`**: `--dry-run`, `--no-remote-delete`, `--force`
 - **`task release`**: `--dry-run`, `--no-merge`, `--merge`, `--rebase`
@@ -120,14 +120,14 @@ pnpm install && pnpm build && pnpm smoke
 
 ## Git
 
-- **Init** records branch policy in `.vibeops.json` (`integrationBranch`, `productionBranch`, `host`).
+- **Init** records branch policy in `.vibeops.json` (`integrationBranch`, `productionBranch`, `host`). Interactive remote setup: ask GitHub/GitLab, create or connect; soft-gate when `gh`/`glab` is missing.
 - **`task add`**: `task/<slug>` from **integration** (e.g. `develop`).
-- **`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 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). Use `--new-cycle` in non-interactive mode. Commit messages are TASK-id-scoped (`feat(task-001): …`). Refuses when HEAD is not the task branch.
 - **`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).
 - **`task release`**: integration → production PR + merge (skipped on trunk policy).
+- **`status`**: Now / Next card — focus stage, checklist, PR, and the next command to run.
 - No force-push to shared branches.
 
 ## License

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { Command } from "commander";
+import { Command, Option } from "commander";
 import { pullCommand } from "./commands/pull.js";
 import { initCommand } from "./commands/init.js";
 import { llmConnectCommand, llmStatusCommand, llmUseCommand } from "./commands/llm.js";
@@ -9,7 +9,6 @@ import { taskDelCommand } from "./commands/task-del.js";
 import { taskMergeCommand } from "./commands/task-merge.js";
 import { taskReleaseCommand } from "./commands/task-release.js";
 import { taskShipCommand } from "./commands/task-ship.js";
-import { taskReshipCommand } from "./commands/task-reship.js";
 import { taskSyncCommand } from "./commands/task-sync.js";
 import { loadVibeopsEnv } from "./lib/env.js";
 import { VERSION } from "./version.js";
@@ -61,7 +60,7 @@ program
 });
 const task = program
     .command("task")
-    .description("TASK lifecycle (add · del · ship · reship · merge · sync · release)");
+    .description("TASK lifecycle (add · del · ship · merge · sync · release)");
 task
     .command("add")
     .description("Create next TASK-NNN, task branch, In Progress")
@@ -99,8 +98,8 @@ task
     .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("--new-cycle", "Allow a new PR cycle after merge without prompting")
+    .addOption(new Option("--reship", "Alias for --new-cycle").hideHelp())
     .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")
@@ -124,27 +123,6 @@ task
         cwd: opts.cwd,
     });
 });
-task
-    .command("reship [taskRef]")
-    .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")
-    .option("--recreate-branch", "Create task branch from integration instead of reusing local/remote ref")
-    .option("--skip-llm", "Do not run LLM for Result / Test Result")
-    .option("--allow-open-mr", "Update the open MR/PR with new commits (merge before reship for a new PR)")
-    .option("--cwd <path>", "Target directory")
-    .action(async (taskRef, opts) => {
-    await taskReshipCommand(taskRef, {
-        dryRun: Boolean(opts.dryRun),
-        noPr: opts.pr === false,
-        noIntegrate: opts.integrate === false,
-        recreateBranch: Boolean(opts.recreateBranch),
-        skipLlm: Boolean(opts.skipLlm),
-        allowOpenMr: Boolean(opts.allowOpenMr),
-        cwd: opts.cwd,
-    });
-});
 task
     .command("merge [taskRef]")
     .description("Merge TASK MR/PR into integration branch (default: squash)")
@@ -165,7 +143,7 @@ task
     .description("After MR merge: integration pull and delete task branch (TASK md unchanged)")
     .option("--dry-run", "Plan only")
     .option("--no-remote-delete", "Keep the task branch on the remote")
-    .option("--force", "Bypass MR merge checks and delete local task branch with -D if not fully merged")
+    .option("--force", "Bypass MR merge verification before branch cleanup")
     .option("--cwd <path>", "Target directory")
     .action(async (taskRef, opts) => {
     await taskSyncCommand(taskRef, {
@@ -177,10 +155,11 @@ task
 });
 task
     .command("release")
-    .description("Open (and merge) release MR/PR: integration branch → production")
+    .description("Open (and merge) release MR/PR: integration branch → production (default: merge commit)")
     .option("--dry-run", "Plan only")
     .option("--no-merge", "Create release PR only")
-    .option("--merge", "Merge commit (instead of squash)")
+    .option("--squash", "Squash merge (default is merge commit for release)")
+    .option("--merge", "Merge commit (default for release)")
     .option("--rebase", "Rebase merge")
     .option("--cwd <path>", "Target directory")
     .action(async (opts) => {
@@ -188,6 +167,7 @@ task
         dryRun: Boolean(opts.dryRun),
         noMerge: Boolean(opts.noMerge),
         merge: Boolean(opts.merge),
+        squash: Boolean(opts.squash),
         rebase: Boolean(opts.rebase),
         cwd: opts.cwd,
     });

package/dist/commands/init.js

@@ -108,30 +108,41 @@ async function resolveBranchPolicy(options, interactive) {
     }
     return { integrationBranch: "develop", productionBranch: "main" };
 }
-function printNextSteps(clients, git) {
+function printNextSteps(clients, git, opts) {
     log.blank();
     log.info("Next steps:");
-    log.info("  1. Read AGENTS.md");
+    let n = 1;
+    log.info(`  ${n++}. Read AGENTS.md`);
     if (clients.includes("cursor")) {
-        log.info("  2. Cursor: @docs/tasks/TASK-001-….md in Ask, then Agent (+ /plan-task, /implement-task)");
+        log.info(`  ${n++}. Cursor: @docs/tasks/TASK-001-….md in Ask, then Agent (+ /plan-task, /implement-task)`);
     }
-    if (clients.includes("claude")) {
-        log.info("  2. Claude Code: open TASK file; use /plan-task then /implement-task");
+    else if (clients.includes("claude")) {
+        log.info(`  ${n++}. Claude Code: open TASK file; use /plan-task then /implement-task`);
     }
-    if (clients.includes("codex")) {
-        log.info("  2. Codex: open TASK file; use $plan-task / $implement-task when needed");
+    else if (clients.includes("codex")) {
+        log.info(`  ${n++}. Codex: open TASK file; use $plan-task / $implement-task when needed`);
     }
-    if (!clients.includes("cursor") && !clients.includes("claude") && !clients.includes("codex")) {
-        log.info("  2. Open the current TASK file in your agent before coding");
+    else {
+        log.info(`  ${n++}. Open the current TASK file in your agent before coding`);
+    }
+    log.info(`  ${n++}. ${cyan("vibeops llm connect")} — LLM for task add / task ship`);
+    if (!opts.hasRemote) {
+        log.info(`  ${n++}. Add a remote later: ${dim(`git remote add ${git.remote} <url>`)} (or re-run init)`);
+    }
+    else if (!opts.pushedBaseline) {
+        log.info(`  ${n++}. Push branches to origin (first time only):`);
+        log.info(`     ${dim(`git push -u ${git.remote} ${git.productionBranch}`)}`);
+        if (git.integrationBranch !== git.productionBranch) {
+            log.info(`     ${dim(`git push -u ${git.remote} ${git.integrationBranch}`)}`);
+        }
     }
-    log.info(`  3. ${cyan("vibeops llm connect")} — LLM for task add / task ship`);
-    log.info("  4. Push branches to origin (first time only):");
-    log.info(`     ${dim(`git push -u ${git.remote} ${git.productionBranch}`)}`);
-    if (git.integrationBranch !== git.productionBranch) {
-        log.info(`     ${dim(`git push -u ${git.remote} ${git.integrationBranch}`)}`);
+    log.info(`  ${n++}. ${cyan("vibeops task add")} — branches from ${git.integrationBranch} (pulls latest first)`);
+    if (opts.hasRemote) {
+        log.info(`  ${n++}. ${cyan("vibeops task ship")} → merge → sync — TASK lifecycle on ${git.host}`);
+    }
+    else {
+        log.info(`  ${n++}. ${cyan("vibeops task ship")} — after origin exists`);
     }
-    log.info(`  5. ${cyan("vibeops task add")} — branches from ${git.integrationBranch} (pulls latest first)`);
-    log.info(`  6. ${cyan("vibeops task ship")} → merge → sync — TASK lifecycle on ${git.host}`);
 }
 export async function initCommand(options = {}) {
     const dryRun = options.dryRun === true;
@@ -223,6 +234,7 @@ export async function initCommand(options = {}) {
         dryRun,
         nonInteractive: !interactive,
         allowMissing: options.allowNoRemote === true,
+        preferredHost: hostFromFlag ?? existingConfig?.git?.host,
         defaultBranch: gitConfig.productionBranch,
     });
     if (remote !== null) {
@@ -232,14 +244,17 @@ export async function initCommand(options = {}) {
             host: remote.host,
         };
     }
+    let pushedBaseline = hadRemoteBefore;
     // If we created/configured a new remote during init, push baseline branches so
     // `task add` can always pull latest integration before branching.
-    if (!dryRun && options.allowNoRemote !== true && !hadRemoteBefore) {
+    if (!dryRun &&
+        options.allowNoRemote !== true &&
+        !hadRemoteBefore &&
+        remote !== null) {
         const remoteName = gitConfig.remote;
         log.blank();
         log.info("Remote bootstrap:");
         try {
-            // Ensure local branches are up-to-date with origin if they already exist remotely.
             const prodRemoteExists = await gitRemoteBranchExists(projectRoot, remoteName, gitConfig.productionBranch);
             if (prodRemoteExists) {
                 await gitCheckout(projectRoot, gitConfig.productionBranch);
@@ -258,6 +273,7 @@ export async function initCommand(options = {}) {
                 await gitPush(projectRoot, remoteName, gitConfig.integrationBranch, true);
                 log.ok(`pushed ${gitConfig.integrationBranch} → ${remoteName}`);
             }
+            pushedBaseline = true;
         }
         catch (e) {
             const msg = e instanceof Error ? e.message : String(e);
@@ -267,14 +283,20 @@ export async function initCommand(options = {}) {
             if (gitConfig.integrationBranch !== gitConfig.productionBranch) {
                 log.info(dim(`  git push -u ${remoteName} ${gitConfig.integrationBranch}`));
             }
+            pushedBaseline = false;
         }
     }
     if (!dryRun) {
         await writeConfig(projectRoot, buildConfig(name, clients, gitConfig, existingConfig));
-        if (options.allowNoRemote === true && remote === null) {
-            log.warn("No git remote configured (--allow-no-remote). task ship push/MR will fail until origin exists.");
+        if (remote === null) {
+            log.warn(options.allowNoRemote === true
+                ? "No git remote configured (--allow-no-remote). task ship push/MR will fail until origin exists."
+                : "No git remote configured. task ship push/MR will fail until origin exists.");
         }
-        printNextSteps(clients, gitConfig);
+        printNextSteps(clients, gitConfig, {
+            hasRemote: remote !== null,
+            pushedBaseline,
+        });
     }
 }
 async function runGitSetup(projectRoot, plan, dryRun) {

package/dist/commands/status.js

@@ -7,7 +7,7 @@ import { buildLlmStatusReport } from "../lib/llm-status.js";
 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 { computeNextHint, hintToLines, hintToText, listInProgressTasks, pickFocusTask, relPath, taskBranchExistsFor, } from "../lib/task-context.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";
@@ -59,6 +59,8 @@ async function buildReport(cwd) {
             taskBranch,
             taskBranchExists: branchExists,
             mergeRequestUrl,
+            mergeRequestMerged,
+            needsSync,
         };
     }
     const hint = computeNextHint({
@@ -85,6 +87,8 @@ async function buildReport(cwd) {
             branch: git.branch,
             dirty: git.dirty,
             policy: config?.git ? formatGitPolicySummary(config.git) : null,
+            host: config?.git?.host ?? null,
+            remote: config?.git?.remote ?? null,
         },
         counts,
         inProgress: inProgress.map((t) => ({
@@ -94,96 +98,111 @@ async function buildReport(cwd) {
         })),
         focus: focusBlock,
         nextHint: hintToText(hint, cwd, focus),
+        nextLines: [...hintToLines(hint, cwd, focus)],
         llm,
     };
 }
-function printHuman(report) {
-    log.blank();
-    log.info(bold("─".repeat(56)));
-    log.info(bold("  VibeOps · status"));
-    log.info(bold("─".repeat(56)));
-    log.info(`  ${dim("CLI")}       v${report.vibeopsVersion}`);
+function filledLabel(ok) {
+    return ok ? green("ok") : yellow("empty");
+}
+function printNow(report) {
+    log.info(bold("  NOW"));
     if (!report.isVibeopsProject) {
-        log.info(`  ${dim("Project")}  ${yellow("not initialized")} — run vibeops init`);
-        log.info(bold("─".repeat(56)));
-        log.blank();
+        log.info(`    ${dim("Project")}   ${yellow("not a VibeOps project")}`);
         return;
     }
-    log.info(`  ${dim("Project")}  ${report.projectName ?? "(unnamed)"}`);
-    if (report.clients.length > 0) {
-        log.info(`  ${dim("Clients")}  ${report.clients.join(", ")}`);
-    }
-    if (report.counts) {
-        const c = report.counts;
-        log.info(`  ${dim("Tasks")}    ${c.total} total · ${cyan(String(c.in_progress))} in progress · ${c.shipped} shipped`);
-    }
-    if (report.inProgress.length > 1) {
-        log.blank();
-        log.info(bold("  In progress"));
-        for (const t of report.inProgress) {
-            log.info(`    ${cyan(t.id)} — ${t.title}`);
-        }
-    }
-    log.blank();
     if (report.focus) {
         const f = report.focus;
-        log.info(`  ${dim("Focus")}    ${cyan(f.id)} — ${f.title || dim("(no title)")}`);
-        log.info(`  ${dim("Status")}  ${f.status}`);
-        log.info(`  ${dim("File")}     ${f.file}`);
-        if (f.goalExcerpt)
-            log.info(`  ${dim("Goal")}     ${f.goalExcerpt}`);
-        log.info(`  ${dim("Result")}  ${f.resultFilled ? green("filled") : yellow("empty")} · Test Result ${f.testResultFilled ? green("filled") : yellow("empty")}`);
+        log.info(`    ${dim("Focus")}     ${cyan(f.id)} — ${f.title || dim("(no title)")}`);
+        log.info(`    ${dim("Stage")}     ${f.status}`);
+        log.info(`    ${dim("Checklist")} Result ${filledLabel(f.resultFilled)} · Test Result ${filledLabel(f.testResultFilled)}`);
+        if (f.taskBranch) {
+            const parts = [];
+            if (f.onTaskBranch === true)
+                parts.push("on it");
+            else if (f.onTaskBranch === false)
+                parts.push("not checked out");
+            if (report.git.dirty === true)
+                parts.push("dirty");
+            else if (report.git.dirty === false)
+                parts.push("clean");
+            const suffix = parts.length > 0 ? `  (${parts.join(" · ")})` : "";
+            log.info(`    ${dim("Branch")}    ${f.taskBranch}${suffix}`);
+        }
+        else if (report.git.isRepo) {
+            log.info(`    ${dim("Branch")}    ${report.git.branch ?? "(detached)"}${report.git.dirty === true ? yellow(" · dirty") : ""}`);
+        }
+        if (f.needsSync) {
+            log.info(`    ${dim("PR")}        ${dim("(merged — sync pending)")}`);
+        }
+        else if (f.mergeRequestUrl) {
+            const tag = f.mergeRequestMerged ? dim(" · merged") : "";
+            log.info(`    ${dim("PR")}        ${f.mergeRequestUrl}${tag}`);
+        }
+        else {
+            log.info(`    ${dim("PR")}        ${dim("(none)")}`);
+        }
     }
     else {
-        log.info(`  ${dim("Focus")}    ${dim("(none)")}`);
+        log.info(`    ${dim("Focus")}     ${dim("(none)")}`);
+        if (report.git.isRepo) {
+            log.info(`    ${dim("Branch")}    ${report.git.branch ?? "(detached)"}${report.git.dirty === true ? yellow(" · dirty") : ""}`);
+        }
     }
+}
+function printNext(report) {
     log.blank();
-    log.info(bold("  Git"));
-    if (!report.git.isRepo) {
-        log.info(`    ${yellow("not a git repository")}`);
+    log.info(bold("  NEXT"));
+    for (const line of report.nextLines) {
+        log.info(`    ${cyan("→")} ${line}`);
     }
-    else {
-        log.info(`    ${dim("HEAD")}     ${report.git.branch ?? "(detached)"}`);
-        if (report.git.dirty === true)
-            log.info(`    ${dim("Tree")}    ${yellow("dirty")}`);
-        else if (report.git.dirty === false)
-            log.info(`    ${dim("Tree")}    ${green("clean")}`);
-        if (report.git.policy) {
-            log.info(`    ${dim("Policy")}   ${report.git.policy}`);
-        }
-        if (report.focus?.taskBranch) {
-            const on = report.focus.onTaskBranch === true
-                ? green("yes")
-                : report.focus.onTaskBranch === false
-                    ? yellow("no")
-                    : dim("—");
-            log.info(`    ${dim("Task br.")}  ${report.focus.taskBranch} · on branch: ${on}`);
-        }
-        if (report.focus?.mergeRequestUrl) {
-            log.info(`    ${dim("MR/PR")}    ${report.focus.mergeRequestUrl}`);
-        }
+}
+function printDetails(report) {
+    log.blank();
+    log.info(dim("  ──"));
+    if (!report.isVibeopsProject) {
+        log.info(`  ${dim("CLI")}       v${report.vibeopsVersion}`);
+        return;
+    }
+    const clients = report.clients.length > 0 ? report.clients.join(", ") : dim("(none)");
+    log.info(`  ${dim("Project")}   ${report.projectName ?? "(unnamed)"} · clients ${clients}`);
+    if (report.counts) {
+        const c = report.counts;
+        log.info(`  ${dim("Tasks")}     ${c.total} total · ${cyan(String(c.in_progress))} in progress · ${c.shipped} shipped`);
+    }
+    if (report.inProgress.length > 1) {
+        log.info(`  ${dim("Active")}    ${report.inProgress.map((t) => t.id).join(", ")}`);
+    }
+    const hostBits = [];
+    if (report.git.host)
+        hostBits.push(report.git.host);
+    if (report.git.remote)
+        hostBits.push(report.git.remote);
+    if (report.git.policy)
+        hostBits.push(report.git.policy);
+    if (hostBits.length > 0) {
+        log.info(`  ${dim("Git")}       ${hostBits.join(" · ")}`);
     }
     if (report.llm) {
-        log.blank();
-        log.info(bold("  LLM"));
-        log.info(`    ${dim("Preferred")}  ${report.llm.preference}`);
         const active = report.llm.active !== null
-            ? green(`${report.llm.active} (ok)`)
+            ? `${report.llm.active} (ok)`
             : report.llm.anyAvailable
-                ? yellow("(preference not available)")
-                : yellow("none");
-        log.info(`    ${dim("Active")}     ${active}`);
-        for (const p of report.llm.providers) {
-            const summary = p.summary.length > 56 ? `${p.summary.slice(0, 53)}…` : p.summary;
-            log.info(`    ${dim(p.id.padEnd(14))} ${p.ok ? green("ok") : dim("—")}  ${dim(summary)}`);
-        }
-        if (!report.llm.anyAvailable) {
-            log.info(`    ${dim("Setup")}     ${cyan("vibeops llm connect")}`);
-        }
+                ? "(preference not available)"
+                : "none";
+        log.info(`  ${dim("LLM")}       ${active} · prefer ${report.llm.preference}${report.llm.anyAvailable ? "" : ` · ${cyan("vibeops llm connect")}`}`);
     }
+}
+function printHuman(report) {
+    log.blank();
+    log.info(bold("─".repeat(44)));
+    log.info(bold("  VibeOps  ·  status"));
+    log.info(bold("─".repeat(44)));
+    log.blank();
+    printNow(report);
+    printNext(report);
+    printDetails(report);
     log.blank();
-    log.info(`${dim("Next")}     ${report.nextHint}`);
-    log.info(bold("─".repeat(56)));
+    log.info(bold("─".repeat(44)));
     log.blank();
 }
 export async function statusCommand(opts = {}) {

package/dist/commands/task-merge.js

@@ -1,5 +1,6 @@
 import { resolve } from "node:path";
 import { GitConfigError, requireGitConfig } from "../lib/git-config.js";
+import { formatHostCliHint, formatHostCliMissingMessage } from "../lib/git-host-cli.js";
 import { detectGitHost, mergeRequestLabel } from "../lib/git-host.js";
 import { gitRemoteUrl } from "../lib/git.js";
 import { bold, cyan, dim, log } from "../lib/logger.js";
@@ -55,7 +56,7 @@ export async function taskMergeCommand(taskRef, options = {}) {
         ? 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.`);
+        log.error(`No open MR/PR for ${ctx.taskBranch} → ${ctx.baseBranch}. Run task ship first.`);
         process.exitCode = 1;
         return;
     }
@@ -96,13 +97,23 @@ export async function taskMergeCommand(taskRef, options = {}) {
     if (state === "open") {
         const cliOk = await probeMergeRequestCli(host);
         if (!cliOk) {
-            const tool = host === "gitlab" ? "glab" : "gh";
-            log.error(`${tool} CLI not found — merge in the host UI, then task sync.`);
+            log.error(formatHostCliMissingMessage(host, `merge the ${label}`));
+            for (const line of formatHostCliHint(host)) {
+                log.info(dim(`  ${line}`));
+            }
+            log.info(dim("Or merge in the host UI, then task sync."));
             process.exitCode = 1;
             return;
         }
         try {
-            await mergeMergeRequest({ cwd, host, url: mergeRequestUrl, method, immediate: true });
+            await mergeMergeRequest({
+                cwd,
+                host,
+                url: mergeRequestUrl,
+                method,
+                waitForCi: true,
+                immediate: true,
+            });
             const verified = await assertMergeRequestMerged({
                 cwd,
                 host,
@@ -132,7 +143,14 @@ export async function taskMergeCommand(taskRef, options = {}) {
     else {
         log.warn(`Could not read ${label} state — attempting merge anyway.`);
         try {
-            await mergeMergeRequest({ cwd, host, url: mergeRequestUrl, method, immediate: true });
+            await mergeMergeRequest({
+                cwd,
+                host,
+                url: mergeRequestUrl,
+                method,
+                waitForCi: true,
+                immediate: true,
+            });
             const verified = await assertMergeRequestMerged({
                 cwd,
                 host,

package/dist/commands/task-release.js

@@ -1,16 +1,17 @@
 import { resolve } from "node:path";
 import { GitConfigError, requireGitConfig } from "../lib/git-config.js";
+import { formatHostCliHint, formatHostCliMissingMessage } from "../lib/git-host-cli.js";
 import { detectGitHost, mergeRequestLabel } from "../lib/git-host.js";
 import { gitRemoteUrl } from "../lib/git.js";
 import { bold, dim, log } from "../lib/logger.js";
 import { createMergeRequest, getMergeRequestState, mergeMergeRequest, probeMergeRequestCli, } from "../lib/pr-create.js";
 import { assertMergeRequestMerged } from "../lib/task-merge-verify.js";
-function resolveMergeMethod(opts) {
+function resolveReleaseMergeMethod(opts) {
     if (opts.rebase === true)
         return "rebase";
-    if (opts.merge === true)
-        return "merge";
-    return "squash";
+    if (opts.squash === true)
+        return "squash";
+    return "merge";
 }
 export async function taskReleaseCommand(options = {}) {
     const cwd = resolve(options.cwd ?? process.cwd());
@@ -51,14 +52,16 @@ export async function taskReleaseCommand(options = {}) {
         log.info(bold("dry-run — would:"));
         log.info(`  · ${label}: ${integrationBranch} → ${productionBranch}`);
         if (options.noMerge !== true) {
-            log.info(`  · merge ${label} (${resolveMergeMethod(options)})`);
+            log.info(`  · merge ${label} (${resolveReleaseMergeMethod(options)}, wait for CI)`);
         }
         return;
     }
     const cliOk = await probeMergeRequestCli(host);
     if (!cliOk) {
-        const tool = host === "gitlab" ? "glab" : "gh";
-        log.error(`${tool} CLI not found — create the release ${label} manually.`);
+        log.error(formatHostCliMissingMessage(host, `create the release ${label}`));
+        for (const line of formatHostCliHint(host)) {
+            log.info(dim(`  ${line}`));
+        }
         process.exitCode = 1;
         return;
     }
@@ -90,9 +93,16 @@ export async function taskReleaseCommand(options = {}) {
         log.ok(`Release ${label} already merged.`);
         return;
     }
-    const method = resolveMergeMethod(options);
+    const method = resolveReleaseMergeMethod(options);
     try {
-        await mergeMergeRequest({ cwd, host, url: releaseUrl, method, immediate: true });
+        await mergeMergeRequest({
+            cwd,
+            host,
+            url: releaseUrl,
+            method,
+            waitForCi: true,
+            immediate: true,
+        });
         const verified = await assertMergeRequestMerged({
             cwd,
             host,