@goodtek/vibeops 2.4.4 → 2.5.0

package/CHANGELOG.md

@@ -4,6 +4,18 @@ 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

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)")

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,8 +97,11 @@ 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;
         }

package/dist/commands/task-release.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, dim, log } from "../lib/logger.js";
@@ -57,8 +58,10 @@ export async function taskReleaseCommand(options = {}) {
     }
     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;
     }

package/dist/lib/git-host-cli.js

@@ -0,0 +1,115 @@
+import { execFile, spawn } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+/** Run a CLI with inherited stdio (e.g. `gh auth login`). */
+export function runInteractiveCli(bin, args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(bin, [...args], { stdio: "inherit" });
+        child.on("error", reject);
+        child.on("close", (code) => resolve(code ?? 1));
+    });
+}
+export function hostCliTool(host) {
+    return host === "gitlab" ? "glab" : "gh";
+}
+export async function commandExists(bin) {
+    try {
+        await execFileAsync(bin, ["--version"], { maxBuffer: 1024 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function probeGhAuth() {
+    try {
+        await execFileAsync("gh", ["auth", "status"], { maxBuffer: 1024 * 1024 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function probeGlabAuth() {
+    try {
+        await execFileAsync("glab", ["auth", "status"], { maxBuffer: 1024 * 1024 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function probeHostCliAuth(host) {
+    const tool = hostCliTool(host);
+    if (!(await commandExists(tool)))
+        return "missing";
+    const ok = host === "gitlab" ? await probeGlabAuth() : await probeGhAuth();
+    return ok ? "ok" : "unauthenticated";
+}
+/** Install / login lines shared by init and ship/merge. */
+export function formatHostCliHint(host) {
+    if (host === "gitlab") {
+        return [
+            `Install glab: https://gitlab.com/gitlab-org/cli#installation`,
+            `  brew install glab`,
+            `Then: glab auth login`,
+        ];
+    }
+    return [
+        `Install gh: https://cli.github.com/`,
+        `  brew install gh`,
+        `Then: gh auth login`,
+    ];
+}
+export function formatHostCliMissingMessage(host, purpose) {
+    const tool = hostCliTool(host);
+    return `${tool} CLI is required to ${purpose}.`;
+}
+export async function probeBrew() {
+    return commandExists("brew");
+}
+export async function brewInstall(pkg) {
+    await execFileAsync("brew", ["install", pkg], {
+        maxBuffer: 16 * 1024 * 1024,
+    });
+}
+/** Parse `owner/repo`, HTTPS, or SSH GitHub/GitLab URLs. */
+export function parseOwnerRepo(input) {
+    const raw = input.trim();
+    if (raw.length === 0)
+        return null;
+    const slug = /^([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+?)(?:\.git)?$/;
+    const fromSlug = slug.exec(raw);
+    if (fromSlug && !raw.includes(":") && !raw.includes("@")) {
+        return { owner: fromSlug[1], repo: fromSlug[2] };
+    }
+    const https = /^https?:\/\/(?:www\.)?(?:github\.com|gitlab\.com)\/([^/]+)\/([^/]+?)(?:\.git)?\/?$/i.exec(raw);
+    if (https) {
+        return { owner: https[1], repo: https[2].replace(/\.git$/i, "") };
+    }
+    const ssh = /^(?:git@|ssh:\/\/git@)(?:github\.com|gitlab\.com)[:/]([^/]+)\/([^/]+?)(?:\.git)?$/i.exec(raw);
+    if (ssh) {
+        return { owner: ssh[1], repo: ssh[2].replace(/\.git$/i, "") };
+    }
+    return null;
+}
+export function remoteUrlForHost(host, owner, repo) {
+    if (host === "gitlab") {
+        return `https://gitlab.com/${owner}/${repo}.git`;
+    }
+    return `https://github.com/${owner}/${repo}.git`;
+}
+export async function repoExistsOnHost(host, owner, repo) {
+    const slug = `${owner}/${repo}`;
+    try {
+        if (host === "gitlab") {
+            await execFileAsync("glab", ["repo", "view", slug], { maxBuffer: 1024 * 1024 });
+            return true;
+        }
+        await execFileAsync("gh", ["repo", "view", slug], { maxBuffer: 1024 * 1024 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/lib/git-remote.js

@@ -1,32 +1,14 @@
+import { basename } from "node:path";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-import { askInput } from "./inquirer-helpers.js";
+import { brewInstall, formatHostCliHint, formatHostCliMissingMessage, hostCliTool, parseOwnerRepo, probeBrew, probeHostCliAuth, remoteUrlForHost, repoExistsOnHost, runInteractiveCli, } from "./git-host-cli.js";
 import { detectGitHost } from "./git-host.js";
 import { gitRemoteUrl, runGit } from "./git.js";
-import { dim, log } from "./logger.js";
+import { askInput, askSelect, askYesNo } from "./inquirer-helpers.js";
+import { dim, log, yellow } from "./logger.js";
 const execFileAsync = promisify(execFile);
-async function probeGh() {
-    try {
-        await execFileAsync("gh", ["auth", "status"], { maxBuffer: 1024 * 1024 });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function probeGlab() {
-    try {
-        await execFileAsync("glab", ["auth", "status"], { maxBuffer: 1024 * 1024 });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
 async function createGithubRepo(cwd, name) {
-    const { stdout } = await execFileAsync("gh", 
-    // gh requires an explicit visibility flag when non-interactive.
-    ["repo", "create", name, "--source=.", "--remote=origin", "--push", "--private"], { cwd, maxBuffer: 8 * 1024 * 1024 });
+    const { stdout } = await execFileAsync("gh", ["repo", "create", name, "--source=.", "--remote=origin", "--push", "--private"], { cwd, maxBuffer: 8 * 1024 * 1024 });
     const match = stdout.match(/https:\/\/github\.com\/[^\s]+/);
     if (match)
         return match[0].replace(/\.git$/, "") + ".git";
@@ -42,8 +24,135 @@ async function createGitlabRepo(cwd, name, defaultBranch) {
         return url;
     throw new Error("glab repo create finished but origin URL could not be read.");
 }
+async function addRemoteUrl(cwd, remote, url) {
+    const host = detectGitHost(url);
+    if (!host) {
+        throw new Error("Only GitHub and GitLab HTTPS/SSH URLs are supported.");
+    }
+    await runGit(cwd, ["remote", "add", remote, url.trim()]);
+    return { remote, url: url.trim(), host };
+}
+async function resolveConnectUrl(host, input) {
+    const trimmed = input.trim();
+    const parsed = parseOwnerRepo(trimmed);
+    if (parsed) {
+        if (trimmed.startsWith("http") || trimmed.startsWith("git@") || trimmed.startsWith("ssh://")) {
+            return trimmed.endsWith(".git") ? trimmed : `${trimmed.replace(/\/$/, "")}.git`;
+        }
+        return remoteUrlForHost(host, parsed.owner, parsed.repo);
+    }
+    if (detectGitHost(trimmed)) {
+        return trimmed.endsWith(".git") ? trimmed : `${trimmed.replace(/\/$/, "")}.git`;
+    }
+    throw new Error(`Could not parse remote: ${trimmed}`);
+}
+async function repairMissingCli(host) {
+    const tool = hostCliTool(host);
+    const status = await probeHostCliAuth(host);
+    log.warn(status === "missing"
+        ? formatHostCliMissingMessage(host, "create a remote repository")
+        : `${tool} is installed but not logged in.`);
+    for (const line of formatHostCliHint(host)) {
+        log.info(dim(`  ${line}`));
+    }
+    const brewOk = status === "missing" ? await probeBrew() : false;
+    const choices = [
+        "I installed / logged in — retry",
+        ...(brewOk ? [`Run brew install ${tool}`] : []),
+        "Enter remote URL manually",
+        "Skip remote for now",
+    ];
+    // Loop so brew install / retry can re-prompt.
+    for (;;) {
+        const pick = await askSelect({
+            message: "How do you want to continue?",
+            nonInteractive: false,
+            choices,
+        });
+        if (pick === "I installed / logged in — retry") {
+            const again = await probeHostCliAuth(host);
+            if (again === "ok")
+                return "retry";
+            log.warn(again === "missing"
+                ? `${tool} still not found on PATH.`
+                : `${tool} still not authenticated. Run \`${tool} auth login\`.`);
+            continue;
+        }
+        if (pick.startsWith("Run brew install")) {
+            log.info(dim(`Running: brew install ${tool}`));
+            try {
+                await brewInstall(tool);
+                log.ok(`Installed ${tool}`);
+                log.info(dim(`Next: ${tool} auth login`));
+                const loginNow = await askYesNo({
+                    message: `Run \`${tool} auth login\` now?`,
+                    nonInteractive: false,
+                    defaultValue: true,
+                });
+                if (loginNow) {
+                    try {
+                        await runInteractiveCli(tool, ["auth", "login"]);
+                    }
+                    catch {
+                        /* user may cancel */
+                    }
+                }
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                log.warn(`brew install failed: ${msg}`);
+            }
+            continue;
+        }
+        if (pick === "Enter remote URL manually")
+            return "manual";
+        return "skip";
+    }
+}
+async function connectExisting(cwd, remote, host) {
+    const input = await askInput({
+        message: "Repository URL or owner/repo",
+        nonInteractive: false,
+        required: true,
+    });
+    const url = await resolveConnectUrl(host, input);
+    const parsed = parseOwnerRepo(url) ?? parseOwnerRepo(input);
+    if (parsed && (await probeHostCliAuth(host)) === "ok") {
+        const exists = await repoExistsOnHost(host, parsed.owner, parsed.repo);
+        if (!exists) {
+            log.warn(yellow(`Could not verify ${parsed.owner}/${parsed.repo} on ${host} (missing or private). Continuing with remote add.`));
+        }
+    }
+    return addRemoteUrl(cwd, remote, url);
+}
+async function createOnHost(cwd, remote, host, defaultBranch) {
+    const folder = basename(cwd);
+    const label = host === "gitlab" ? "GitLab project path (group/project)" : "GitHub repository (owner/repo or name)";
+    const name = await askInput({
+        message: label,
+        nonInteractive: false,
+        required: true,
+        default: folder,
+    });
+    log.info(dim(`Creating ${host} repository via ${hostCliTool(host)}…`));
+    if (host === "gitlab") {
+        const url = await createGitlabRepo(cwd, name, defaultBranch);
+        // glab may name remote differently; ensure our remote name.
+        const current = await gitRemoteUrl(cwd, remote);
+        if (!current) {
+            const origin = await gitRemoteUrl(cwd, "origin");
+            if (origin && remote !== "origin") {
+                await runGit(cwd, ["remote", "rename", "origin", remote]);
+            }
+        }
+        return { remote, url, host };
+    }
+    const url = await createGithubRepo(cwd, name);
+    return { remote, url, host };
+}
 /**
- * Ensures `origin` (or named remote) exists. Interactive path can create via gh/glab or manual URL.
+ * Ensures `origin` (or named remote) exists.
+ * Interactive: ask host → create/connect; soft-gate when CLI missing.
  */
 export async function ensureOriginRemote(opts) {
     const remote = opts.remoteName ?? "origin";
@@ -59,8 +168,9 @@ export async function ensureOriginRemote(opts) {
         return { remote, url: existing, host };
     }
     if (opts.dryRun) {
-        log.info(dim(`would configure git remote ${remote}`));
-        return { remote, url: "(dry-run)", host: "github" };
+        const host = opts.preferredHost ?? "github";
+        log.info(dim(`would configure git remote ${remote} (${host})`));
+        return { remote, url: "(dry-run)", host };
     }
     if (opts.allowMissing) {
         return null;
@@ -69,40 +179,48 @@ export async function ensureOriginRemote(opts) {
         throw new Error(`Git remote "${remote}" is not configured. Add it with: git remote add ${remote} <url>`);
     }
     log.blank();
-    log.info("Remote origin is required for push and merge requests.");
-    const ghOk = await probeGh();
-    const glabOk = await probeGlab();
-    if (ghOk) {
-        const name = await askInput({
-            message: "GitHub repository name (owner/repo or name for gh to create)",
-            nonInteractive: false,
-            required: true,
-        });
-        log.info(dim("Creating GitHub repository via gh…"));
-        const url = await createGithubRepo(opts.cwd, name);
-        return { remote, url, host: "github" };
-    }
-    if (glabOk) {
-        const name = await askInput({
-            message: "GitLab project path (group/project)",
-            nonInteractive: false,
-            required: true,
-        });
-        log.info(dim("Creating GitLab project via glab…"));
-        const defaultBranch = typeof opts.defaultBranch === "string" && opts.defaultBranch.length > 0
-            ? opts.defaultBranch
-            : "main";
-        const url = await createGitlabRepo(opts.cwd, name, defaultBranch);
-        return { remote, url, host: "gitlab" };
+    log.info("Remote setup — used later for pull requests / merge requests.");
+    const hostPick = await askSelect({
+        message: "Where will this project's remote live?",
+        nonInteractive: false,
+        choices: ["GitHub", "GitLab", "Skip for now (local only)"],
+        default: opts.preferredHost === "gitlab"
+            ? "GitLab"
+            : opts.preferredHost === "github"
+                ? "GitHub"
+                : undefined,
+    });
+    if (hostPick.startsWith("Skip")) {
+        log.warn("No git remote configured. task ship push/MR will fail until origin exists.");
+        log.info(dim(`  Later: git remote add ${remote} <url>`));
+        return null;
     }
-    const url = await askInput({
-        message: `Remote URL for ${remote} (https://github.com/… or https://gitlab.com/…)`,
+    const host = hostPick === "GitLab" ? "gitlab" : "github";
+    const mode = await askSelect({
+        message: "Set up the remote",
         nonInteractive: false,
-        required: true,
+        choices: ["Create a new repository", "Connect an existing repository"],
     });
-    await runGit(opts.cwd, ["remote", "add", remote, url.trim()]);
-    const host = detectGitHost(url);
-    if (!host)
-        throw new Error("Only GitHub and GitLab HTTPS/SSH URLs are supported.");
-    return { remote, url: url.trim(), host };
+    if (mode.startsWith("Connect")) {
+        return connectExisting(opts.cwd, remote, host);
+    }
+    // Create path — requires authenticated CLI (soft gate).
+    for (;;) {
+        const auth = await probeHostCliAuth(host);
+        if (auth === "ok") {
+            const defaultBranch = typeof opts.defaultBranch === "string" && opts.defaultBranch.length > 0
+                ? opts.defaultBranch
+                : "main";
+            return createOnHost(opts.cwd, remote, host, defaultBranch);
+        }
+        const action = await repairMissingCli(host);
+        if (action === "retry")
+            continue;
+        if (action === "manual") {
+            return connectExisting(opts.cwd, remote, host);
+        }
+        log.warn("No git remote configured. task ship push/MR will fail until origin exists.");
+        log.info(dim(`  Later: git remote add ${remote} <url>`));
+        return null;
+    }
 }

package/dist/lib/task-context.js

@@ -49,7 +49,7 @@ export function computeNextHint(input) {
         if (input.hasMergeRequest && !input.mergeRequestMerged)
             return "task-merge";
         if (input.hasLocalChanges)
-            return "task-reship";
+            return "task-ship-followup";
         return "task-add";
     }
     if (!input.resultFilled || !input.testFilled) {
@@ -57,36 +57,48 @@ export function computeNextHint(input) {
     }
     return input.hasMergeRequest ? "task-merge" : "task-ship";
 }
-export function hintToText(hint, cwd, task) {
+/** Multi-line NEXT block lines (without the leading arrow prefix). */
+export function hintToLines(hint, cwd, task) {
     switch (hint) {
         case "init":
-            return "Run `vibeops init` in this directory.";
+            return ["vibeops init"];
         case "task-add":
-            return "Run `vibeops task add` to start the next slice.";
+            return ["vibeops task add"];
         case "task-ship":
-            return task ? `Run \`vibeops task ship ${task.id}\`.` : "Run `vibeops task ship`.";
-        case "task-reship":
+            return [task ? `vibeops task ship ${task.id}` : "vibeops task ship"];
+        case "task-ship-followup":
             return task
-                ? `Follow-up on ${task.id}? Edit files (develop is fine), then \`vibeops task reship ${task.id}\`.`
-                : "Run `vibeops task reship TASK-NNN` for a Shipped follow-up.";
+                ? [
+                    `Follow up on ${task.id} (after merge: confirm or --new-cycle)`,
+                    `vibeops task ship ${task.id}`,
+                ]
+                : ["vibeops task ship --new-cycle"];
         case "task-merge":
             return task
-                ? `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`.";
+                ? [`vibeops task merge ${task.id}`, "(or merge in the host UI)"]
+                : ["vibeops task merge"];
         case "task-sync":
             return task
-                ? `Run \`vibeops task sync ${task.id}\` to delete task branches, then task add.`
-                : "Run `vibeops task sync` to delete task branches after merge.";
+                ? [`vibeops task sync ${task.id}`, "then: vibeops task add"]
+                : ["vibeops task sync"];
         case "cursor-plan":
             return task
-                ? `In Cursor Ask: @${relPath(cwd, task.filePath)} — refine Scope / AC.`
-                : "Open the TASK file in Cursor Ask.";
+                ? [
+                    `Cursor Ask: @${relPath(cwd, task.filePath)} — refine Scope / AC`,
+                ]
+                : ["Open the TASK file in Cursor Ask"];
         case "cursor-implement":
             return task
-                ? `In Cursor Agent: @${relPath(cwd, task.filePath)} — implement, then task ship.`
-                : "Implement per the TASK file in Cursor.";
+                ? [
+                    `Cursor Agent: @${relPath(cwd, task.filePath)} — implement`,
+                    `then: vibeops task ship ${task.id}`,
+                ]
+                : ["Implement per the TASK file, then vibeops task ship"];
     }
 }
+export function hintToText(hint, cwd, task) {
+    return hintToLines(hint, cwd, task).join(" · ");
+}
 export async function listInProgressTasks(paths) {
     return (await loadActionableTasks(paths.docsTasks)).filter((t) => t.status === "in_progress");
 }

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

@@ -1,3 +1,4 @@
+import { formatHostCliHint, formatHostCliMissingMessage } from "./git-host-cli.js";
 import { readText } from "./filesystem.js";
 import { readConfig } from "./config.js";
 import { detectGitHost, mergeRequestLabel } from "./git-host.js";
@@ -94,8 +95,11 @@ export async function finishTaskWithPullRequest(opts) {
     }
     const cliOk = await probeMergeRequestCli(gitCfg.host);
     if (!cliOk) {
-        const tool = gitCfg.host === "gitlab" ? "glab" : "gh";
-        log.warn(`${tool} CLI not found — create the ${label} manually: ${gitCtx.taskBranch} → ${gitCtx.baseBranch}`);
+        log.warn(formatHostCliMissingMessage(gitCfg.host, `create the ${label}`));
+        for (const line of formatHostCliHint(gitCfg.host)) {
+            log.info(dim(`  ${line}`));
+        }
+        log.info(dim(`Create the ${label} manually: ${gitCtx.taskBranch} → ${gitCtx.baseBranch}`));
         return { ok: true, pushed: true };
     }
     const config = await readConfig(opts.cwd);

package/dist/lib/task-reship.js

@@ -43,7 +43,7 @@ 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`.";
+    return "No Shipped TASK found. Pass `vibeops task ship TASK-NNN` (use --new-cycle after merge).";
 }
 async function switchToTaskBranch(cwd, taskBranch) {
     try {

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@goodtek/vibeops",
-  "version": "2.4.4",
+  "version": "2.5.0",
   "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,17 @@
   "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",
+    "test": "pnpm build && node --test \"tests/*.test.mjs\"",
+    "smoke": "pnpm typecheck && pnpm build && node --test \"tests/*.test.mjs\" && node scripts/smoke.mjs",
+    "clean": "rm -rf dist",
+    "prepack": "pnpm clean && pnpm build",
+    "publish:dry": "pnpm publish --dry-run --no-git-checks"
+  },
   "keywords": [
     "cursor",
     "ai",
@@ -47,15 +59,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",
-    "test": "pnpm build && node --test \"tests/*.test.mjs\"",
-    "smoke": "pnpm typecheck && pnpm build && node --test \"tests/*.test.mjs\" && node scripts/smoke.mjs",
-    "clean": "rm -rf dist",
-    "publish:dry": "pnpm publish --dry-run --no-git-checks"
   }
-}
+}

package/templates/core/AGENTS.md

@@ -40,5 +40,5 @@ vibeops llm connect   # optional — task add / ship
 
 - One **In Progress** TASK at a time; **Shipped** does not block `task add`.
 - Fill **Result** and **Test Result** before `vibeops task ship` (warned, not blocked, when updating an open PR).
-- `ship` is state-aware: re-run it to update an open PR; after merge it needs `--new-cycle` (or a confirm) to start a new PR cycle. `task reship` still works as a deprecated alias for `task ship --new-cycle`.
+- `ship` is state-aware: re-run it to update an open PR; after merge it needs `--new-cycle` (or a confirm) to start a new PR cycle.
 - Agents do not run `task merge` or `task sync` unless the human asks.

package/templates/core/docs/project/06-decisions.md

@@ -5,5 +5,5 @@
 ## D-001 · VibeOps workflow
 
 - **Date:** {{CREATED_AT}}
-- **Decision:** TASK-driven development with `vibeops task add` / `task ship` / `task reship` / `merge` / `sync` and Cursor for plan/build. TASK status: **In Progress** → **Shipped** only.
+- **Decision:** TASK-driven development with `vibeops task add` / `task ship` / `merge` / `sync` and Cursor for plan/build. TASK status: **In Progress** → **Shipped** only.
 - **Why:** Git `docs/tasks` beats chat as source of truth.

package/dist/commands/task-reship.js

@@ -1,21 +0,0 @@
-import { dim, log, yellow } from "../lib/logger.js";
-import { taskShipCommand } from "./task-ship.js";
-/**
- * @deprecated `reship` is now `vibeops task ship --new-cycle`.
- * Kept as a thin alias for backward compatibility.
- */
-export async function taskReshipCommand(taskRef, options = {}) {
-    log.warn(`${yellow("reship is now `ship` (deprecated alias)")} — delegating to \`vibeops task ship --new-cycle\`.`);
-    log.info(dim("Run `vibeops task ship` directly; it detects first submit / open-PR update / new PR cycle."));
-    log.blank();
-    await taskShipCommand(taskRef, {
-        dryRun: options.dryRun,
-        cwd: options.cwd,
-        noPr: options.noPr,
-        newCycle: true,
-        noIntegrate: options.noIntegrate,
-        recreateBranch: options.recreateBranch,
-        skipLlm: options.skipLlm,
-        allowOpenMr: options.allowOpenMr,
-    });
-}