@goodtek/vibeops 1.0.0 → 1.1.1

package/dist/commands/init.js

@@ -1,10 +1,12 @@
 import { basename, resolve } from "node:path";
 import { install, printReport } from "../bootstrap/installer.js";
-import { buildConfig } from "../lib/config.js";
-import { currentBranchOrUnborn, gitAddAll, gitCommit, gitInit, gitSetDefaultBranch, gitStatusPorcelain, hasAnyCommit, isGitRepository, } from "../lib/git.js";
+import { buildConfig, isVibeopsProject, readConfig, writeConfig } from "../lib/config.js";
+import { gitAddAll, gitBranchExists, gitCheckout, gitCommit, gitCreateBranch, gitInit, gitPullFastForwardOnly, gitPush, gitRemoteBranchExists, gitRemoteUrl, gitSetDefaultBranch, gitStatusPorcelain, hasAnyCommit, isGitRepository, } from "../lib/git.js";
+import { formatGitPolicySummary, askGitPolicy, parseGitPolicyArg, resolvePreset } from "../lib/git-policy.js";
+import { ensureOriginRemote } from "../lib/git-remote.js";
+import { askInitClients, formatClientsList, parseClientsArg, } from "../lib/init-clients.js";
 import { askInput, askYesNo } from "../lib/inquirer-helpers.js";
 import { cyan, dim, green, log, yellow } from "../lib/logger.js";
-const DEFAULT_BRANCH = "main";
 const DEFAULT_COMMIT_MESSAGE = "chore: initialize vibeops project";
 function deriveProjectName(root, explicit) {
     if (explicit && explicit.trim().length > 0)
@@ -14,124 +16,282 @@ function deriveProjectName(root, explicit) {
         return base;
     return "untitled-project";
 }
+function parseGitHostArg(raw) {
+    if (raw === undefined || raw.trim().length === 0)
+        return null;
+    const t = raw.trim().toLowerCase();
+    if (t === "github" || t === "gitlab")
+        return t;
+    return null;
+}
+async function confirmReinitIfNeeded(projectRoot, options) {
+    const existing = await isVibeopsProject(projectRoot);
+    if (!existing)
+        return true;
+    if (options.dryRun) {
+        log.info(dim("(dry-run) would re-initialize existing VibeOps project templates"));
+        return true;
+    }
+    if (options.yes === true || options.force === true) {
+        log.warn("Re-initializing existing VibeOps project (templates will be overwritten).");
+        return true;
+    }
+    if (process.stdin.isTTY !== true) {
+        log.error("This directory is already a VibeOps project. Use --yes to re-run init, or --force.");
+        process.exitCode = 1;
+        return false;
+    }
+    log.warn(yellow("This directory is already a VibeOps project."));
+    log.info(dim("Re-running init overwrites AGENTS.md, client rules/skills, and project doc stubs. docs/tasks/TASK-*.md are kept."));
+    log.blank();
+    const proceed = await askYesNo({
+        message: "Continue and overwrite template files?",
+        nonInteractive: false,
+        defaultValue: false,
+    });
+    if (!proceed) {
+        log.info(dim("Stopped — no files changed."));
+        process.exitCode = 1;
+        return false;
+    }
+    return true;
+}
+async function resolveClients(options, interactive) {
+    const fromFlag = parseClientsArg(options.clients);
+    if (options.clients !== undefined && fromFlag === null) {
+        log.error('Invalid --clients. Use comma-separated: cursor, claude, codex (e.g. --clients cursor,claude)');
+        process.exitCode = 1;
+        return null;
+    }
+    if (fromFlag !== null)
+        return fromFlag;
+    if (interactive) {
+        log.blank();
+        log.info("Agent clients");
+        return askInitClients();
+    }
+    if (options.dryRun) {
+        return ["cursor"];
+    }
+    log.error("Select at least one agent: --clients cursor,claude,codex (non-interactive mode).");
+    process.exitCode = 1;
+    return null;
+}
+async function resolveBranchPolicy(options, interactive) {
+    const presetId = parseGitPolicyArg(options.gitPolicy);
+    if (options.gitPolicy !== undefined && presetId === null) {
+        log.error("Invalid --git-policy. Use: gitflow, trunk, or custom");
+        process.exitCode = 1;
+        return null;
+    }
+    if (typeof options.integrationBranch === "string" &&
+        typeof options.productionBranch === "string") {
+        return {
+            integrationBranch: options.integrationBranch.trim(),
+            productionBranch: options.productionBranch.trim(),
+        };
+    }
+    if (presetId !== null && presetId !== "custom") {
+        const p = resolvePreset(presetId);
+        return {
+            integrationBranch: p.integrationBranch,
+            productionBranch: p.productionBranch,
+        };
+    }
+    if (interactive) {
+        log.blank();
+        log.info("Branch policy");
+        return askGitPolicy();
+    }
+    if (options.dryRun) {
+        return { integrationBranch: "develop", productionBranch: "main" };
+    }
+    return { integrationBranch: "develop", productionBranch: "main" };
+}
+function printNextSteps(clients, git) {
+    log.blank();
+    log.info("Next steps:");
+    log.info("  1. Read AGENTS.md");
+    if (clients.includes("cursor")) {
+        log.info("  2. 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");
+    }
+    if (clients.includes("codex")) {
+        log.info("  2. 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");
+    }
+    log.info(`  3. ${cyan("vibeops llm connect")} — LLM for task add / task done`);
+    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(`  5. ${cyan("vibeops task add")} — branches from ${git.integrationBranch} (pulls latest first)`);
+    log.info(`  6. ${cyan("vibeops task done")} — push + open MR/PR; merge on ${git.host} (CI deploys)`);
+}
 export async function initCommand(options = {}) {
     const dryRun = options.dryRun === true;
-    const force = options.force === true;
     const projectRoot = resolve(options.cwd ?? process.cwd());
-    const interactive = !dryRun && process.stdin.isTTY === true && options.git === undefined;
-    const name = deriveProjectName(projectRoot, options.name);
-    const config = buildConfig(name);
+    const interactive = !dryRun &&
+        process.stdin.isTTY === true &&
+        options.clients === undefined &&
+        options.gitPolicy === undefined;
+    const proceed = await confirmReinitIfNeeded(projectRoot, options);
+    if (!proceed)
+        return;
+    const existingConfig = await readConfig(projectRoot);
+    const reinit = existingConfig !== null || (await isVibeopsProject(projectRoot));
+    const force = options.force === true || reinit;
+    const clients = await resolveClients(options, interactive);
+    if (clients === null)
+        return;
+    const branchPolicy = await resolveBranchPolicy(options, interactive);
+    if (branchPolicy === null)
+        return;
+    const hostFromFlag = parseGitHostArg(options.gitHost);
+    if (options.gitHost !== undefined && hostFromFlag === null) {
+        log.error("Invalid --git-host. Use: github or gitlab");
+        process.exitCode = 1;
+        return;
+    }
+    let gitConfig = {
+        remote: "origin",
+        host: hostFromFlag ?? existingConfig?.git?.host ?? "github",
+        integrationBranch: branchPolicy.integrationBranch,
+        productionBranch: branchPolicy.productionBranch,
+    };
+    const name = options.name?.trim() ||
+        existingConfig?.name ||
+        deriveProjectName(projectRoot, options.name);
+    const config = buildConfig(name, clients, gitConfig, existingConfig);
     log.step(`vibeops init ${dryRun ? "(dry-run) " : ""}→ ${projectRoot}`);
     log.info(`  project: ${name}`);
     log.info(`  vibeops: ${config.vibeopsVersion}`);
-    if (force)
-        log.warn("--force is on — existing files will be overwritten.");
+    log.info(`  clients: ${formatClientsList(clients)}`);
+    log.info(`  git:     ${formatGitPolicySummary(gitConfig)}`);
+    if (force && reinit)
+        log.warn("Template files will be overwritten where they already exist.");
     log.blank();
-    const report = await install({ projectRoot, config, dryRun, force });
+    const report = await install({
+        projectRoot,
+        config,
+        clients,
+        dryRun,
+        force,
+    });
     printReport(report, dryRun);
-    const gitPlan = await resolveGitPlan(options, interactive);
-    await runGitSetup(projectRoot, gitPlan, dryRun);
-    if (!dryRun) {
-        log.blank();
-        log.info("Next steps:");
-        log.info("  1. Read AGENTS.md and `.cursor/rules/`.");
-        log.info("  2. Run `vibeops task add` to create the first TASK.");
-        log.info("  3. Plan in Cursor Ask (@docs/tasks/TASK-001-….md), then implement.");
-    }
-}
-async function resolveGitPlan(options, interactive) {
-    const defaultBranch = typeof options.defaultBranch === "string" && options.defaultBranch.trim().length > 0
-        ? options.defaultBranch.trim()
-        : DEFAULT_BRANCH;
     const commitMessage = typeof options.commitMessage === "string" && options.commitMessage.trim().length > 0
         ? options.commitMessage.trim()
         : DEFAULT_COMMIT_MESSAGE;
-    if (interactive) {
+    let shouldInitialCommit = options.initialCommit !== false &&
+        (options.initialCommit === true || options.git === true);
+    let finalCommitMessage = commitMessage;
+    if (interactive && !dryRun) {
         log.blank();
-        log.info("Git setup");
-        const shouldInitGit = await askYesNo({
-            message: "Initialize Git repository?",
-            nonInteractive: false,
-            defaultValue: true,
-        });
-        if (!shouldInitGit) {
-            return {
-                shouldInitGit: false,
-                shouldSetDefaultBranch: false,
-                defaultBranch,
-                shouldInitialCommit: false,
-                commitMessage,
-            };
-        }
-        const useMain = await askYesNo({
-            message: "Use `main` as default branch?",
-            nonInteractive: false,
-            defaultValue: true,
-        });
-        const shouldInitialCommit = await askYesNo({
+        log.info("Git repository");
+        shouldInitialCommit = await askYesNo({
             message: "Create initial commit?",
             nonInteractive: false,
             defaultValue: true,
         });
-        const finalMessage = shouldInitialCommit
-            ? await askInput({
+        if (shouldInitialCommit) {
+            finalCommitMessage = await askInput({
                 message: "Initial commit message",
                 nonInteractive: false,
                 default: commitMessage,
                 required: true,
-            })
-            : commitMessage;
-        return {
-            shouldInitGit: true,
-            shouldSetDefaultBranch: useMain,
-            defaultBranch,
-            shouldInitialCommit,
-            commitMessage: finalMessage.length > 0 ? finalMessage : commitMessage,
-        };
+            });
+        }
     }
-    const shouldInitGit = options.git !== false && (options.git === true || options.initialCommit === true);
-    if (!shouldInitGit) {
-        return {
-            shouldInitGit: false,
-            shouldSetDefaultBranch: false,
-            defaultBranch,
-            shouldInitialCommit: false,
-            commitMessage,
+    else if (!dryRun && !shouldInitialCommit && options.initialCommit === undefined) {
+        shouldInitialCommit = true;
+    }
+    await runGitSetup(projectRoot, {
+        productionBranch: gitConfig.productionBranch,
+        integrationBranch: gitConfig.integrationBranch,
+        shouldInitialCommit,
+        commitMessage: finalCommitMessage,
+    }, dryRun);
+    const hadRemoteBefore = (await gitRemoteUrl(projectRoot, gitConfig.remote)) !== null;
+    const remote = await ensureOriginRemote({
+        cwd: projectRoot,
+        remoteName: gitConfig.remote,
+        dryRun,
+        nonInteractive: !interactive,
+        allowMissing: options.allowNoRemote === true,
+        defaultBranch: gitConfig.productionBranch,
+    });
+    if (remote !== null) {
+        gitConfig = {
+            ...gitConfig,
+            remote: remote.remote,
+            host: remote.host,
         };
     }
-    return {
-        shouldInitGit: true,
-        shouldSetDefaultBranch: true,
-        defaultBranch,
-        shouldInitialCommit: options.initialCommit !== false,
-        commitMessage,
-    };
+    // 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) {
+        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);
+                await gitPullFastForwardOnly(projectRoot, remoteName, gitConfig.productionBranch);
+            }
+            await gitCheckout(projectRoot, gitConfig.productionBranch);
+            await gitPush(projectRoot, remoteName, gitConfig.productionBranch, true);
+            log.ok(`pushed ${gitConfig.productionBranch} → ${remoteName}`);
+            if (gitConfig.integrationBranch !== gitConfig.productionBranch) {
+                const intRemoteExists = await gitRemoteBranchExists(projectRoot, remoteName, gitConfig.integrationBranch);
+                if (intRemoteExists) {
+                    await gitCheckout(projectRoot, gitConfig.integrationBranch);
+                    await gitPullFastForwardOnly(projectRoot, remoteName, gitConfig.integrationBranch);
+                }
+                await gitCheckout(projectRoot, gitConfig.integrationBranch);
+                await gitPush(projectRoot, remoteName, gitConfig.integrationBranch, true);
+                log.ok(`pushed ${gitConfig.integrationBranch} → ${remoteName}`);
+            }
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            log.warn(`Automatic push failed: ${msg}`);
+            log.info(dim("Run these manually:"));
+            log.info(dim(`  git push -u ${remoteName} ${gitConfig.productionBranch}`));
+            if (gitConfig.integrationBranch !== gitConfig.productionBranch) {
+                log.info(dim(`  git push -u ${remoteName} ${gitConfig.integrationBranch}`));
+            }
+        }
+    }
+    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 done push/MR will fail until origin exists.");
+        }
+        printNextSteps(clients, gitConfig);
+    }
 }
 async function runGitSetup(projectRoot, plan, dryRun) {
     log.blank();
     log.info("Git setup:");
-    if (!plan.shouldInitGit) {
-        log.info(`  ${dim("skipped")} Git initialization`);
-        if (dryRun) {
-            log.info(`  ${dim("hint")} use ${cyan("vibeops init --git --initial-commit")} to include Git setup in non-interactive mode`);
-        }
-        return;
-    }
     const alreadyRepo = await isGitRepository(projectRoot);
     const hasCommitsBefore = alreadyRepo ? await hasAnyCommit(projectRoot) : false;
     if (dryRun) {
         log.info(`  ${alreadyRepo ? dim("would skip") : green("would run")} git init`);
-        if (plan.shouldSetDefaultBranch) {
-            log.info(`  ${green("would set")} default branch ${cyan(plan.defaultBranch)}`);
+        log.info(`  ${green("would set")} production branch ${cyan(plan.productionBranch)}`);
+        if (plan.integrationBranch !== plan.productionBranch) {
+            log.info(`  ${green("would create")} integration branch ${cyan(plan.integrationBranch)}`);
         }
         if (plan.shouldInitialCommit) {
-            log.info(`  ${green("would run")} git add .`);
-            log.info(`  ${green("would run")} git commit -m ${JSON.stringify(plan.commitMessage)}`);
-        }
-        else {
-            log.info(`  ${dim("would skip")} initial commit`);
+            log.info(`  ${green("would run")} git add . && git commit`);
         }
-        log.info(`  ${dim("dry-run")} no git commands executed`);
+        log.info(`  ${dim("would require")} remote origin (unless --allow-no-remote)`);
         return;
     }
     if (alreadyRepo) {
@@ -141,39 +301,44 @@ async function runGitSetup(projectRoot, plan, dryRun) {
         await gitInit(projectRoot);
         log.ok("git init");
     }
-    if (plan.shouldSetDefaultBranch) {
-        const hasCommitsNow = await hasAnyCommit(projectRoot);
-        if (alreadyRepo && hasCommitsNow) {
-            log.info(`  ${yellow("skipped")} default branch change (repository already has commits)`);
+    const hasCommitsNow = await hasAnyCommit(projectRoot);
+    if (!hasCommitsNow) {
+        await gitSetDefaultBranch(projectRoot, plan.productionBranch);
+        log.ok(`production branch ${plan.productionBranch}`);
+    }
+    else {
+        log.info(`  ${yellow("skipped")} default branch change (repository already has commits)`);
+    }
+    if (plan.shouldInitialCommit && !hasCommitsBefore && !hasCommitsNow) {
+        const changedFiles = await gitStatusPorcelain(projectRoot);
+        if (changedFiles.length > 0) {
+            await gitAddAll(projectRoot);
+            await gitCommit(projectRoot, plan.commitMessage);
+            log.ok(`initial commit on ${plan.productionBranch}`);
         }
         else {
-            await gitSetDefaultBranch(projectRoot, plan.defaultBranch);
-            log.ok(`default branch ${plan.defaultBranch}`);
+            log.info(`  ${dim("skipped")} initial commit (nothing to commit)`);
         }
     }
-    if (!plan.shouldInitialCommit) {
-        log.info(`  ${dim("skipped")} initial commit`);
-        return;
+    else if (hasCommitsNow || hasCommitsBefore) {
+        log.info(`  ${dim("skipped")} initial commit (repository already has commits)`);
     }
-    if (hasCommitsBefore || (await hasAnyCommit(projectRoot))) {
-        log.info(`  ${yellow("skipped")} initial commit (repository already has commits)`);
+    await ensureIntegrationBranch(projectRoot, plan);
+}
+/** Create integration branch when missing (including re-init on existing repos). */
+async function ensureIntegrationBranch(projectRoot, plan) {
+    if (plan.integrationBranch === plan.productionBranch)
         return;
-    }
-    const changedFiles = await gitStatusPorcelain(projectRoot);
-    log.info(`  ${dim("initial commit files")} ${changedFiles.length} file${changedFiles.length === 1 ? "" : "s"} will be included`);
-    if (changedFiles.length === 0) {
-        log.info(`  ${dim("skipped")} initial commit (nothing to commit)`);
+    if (await gitBranchExists(projectRoot, plan.integrationBranch))
         return;
-    }
-    try {
-        await gitAddAll(projectRoot);
-        await gitCommit(projectRoot, plan.commitMessage);
-        const branch = await currentBranchOrUnborn(projectRoot);
-        log.ok(`initial commit created${branch.branch !== null ? ` on ${branch.branch}` : ""}`);
-    }
-    catch (err) {
-        log.error(`initial commit failed: ${err.message}`);
-        log.info(`  ${dim("hint")} check Git user.name/user.email, then run ${cyan(`git commit -m ${JSON.stringify(plan.commitMessage)}`)} manually.`);
-        process.exitCode = 1;
+    if (!(await hasAnyCommit(projectRoot)))
+        return;
+    const start = (await gitBranchExists(projectRoot, plan.productionBranch))
+        ? plan.productionBranch
+        : "HEAD";
+    await gitCreateBranch(projectRoot, plan.integrationBranch, start);
+    log.ok(`integration branch ${plan.integrationBranch}`);
+    if (await gitBranchExists(projectRoot, plan.productionBranch)) {
+        await gitCheckout(projectRoot, plan.productionBranch);
     }
 }

package/dist/commands/llm.js

@@ -0,0 +1,177 @@
+import { resolve } from "node:path";
+import { password, select } from "@inquirer/prompts";
+import { readConfig, setLlmProviderPreference } from "../lib/config.js";
+import { configureOpenAiKey, guideCodexOAuth, printConnectSetupHint, runCursorAgentLogin, } from "../lib/llm-connect.js";
+import { getLlmPreferenceFromConfig, labelLlmProvider, parseLlmProviderPreference, probeAllLlmProviders, resolveLlmProviderForUse, } from "../lib/llm-preference.js";
+import { buildLlmStatusReport, formatLlmStatusLine } from "../lib/llm-status.js";
+import { bold, cyan, dim, green, log, yellow } from "../lib/logger.js";
+async function requireProject(cwd) {
+    const c = await readConfig(cwd);
+    if (c === null) {
+        log.error("Not a VibeOps project — run vibeops init first.");
+        process.exitCode = 1;
+        return false;
+    }
+    return true;
+}
+async function printLlmStatusHuman(cwd) {
+    const report = await buildLlmStatusReport(cwd);
+    const { preferenceLabel, activeLabel } = formatLlmStatusLine(report);
+    log.blank();
+    log.info(bold("  LLM"));
+    log.info(`    ${dim("Preferred")}  ${preferenceLabel}`);
+    log.info(`    ${dim("Active")}     ${report.active !== null ? green(activeLabel) : yellow(activeLabel)}`);
+    for (const p of report.providers) {
+        const mark = p.ok ? green("ok") : dim("—");
+        log.info(`    ${dim(p.id.padEnd(14))} ${mark}  ${dim(p.summary)}`);
+    }
+    if (!report.anyAvailable) {
+        log.info(`    ${dim("Hint")}      Run ${cyan("vibeops llm connect")}`);
+    }
+    log.blank();
+}
+export async function llmStatusCommand(opts = {}) {
+    const cwd = resolve(opts.cwd ?? process.cwd());
+    if (!(await requireProject(cwd)))
+        return;
+    if (opts.json) {
+        const report = await buildLlmStatusReport(cwd);
+        log.raw(JSON.stringify(report, null, 2));
+        return;
+    }
+    await printLlmStatusHuman(cwd);
+}
+export async function llmUseCommand(providerArg, opts = {}) {
+    const cwd = resolve(opts.cwd ?? process.cwd());
+    if (!(await requireProject(cwd)))
+        return;
+    const nonInteractive = opts.nonInteractive === true || process.stdin.isTTY !== true;
+    let preference = null;
+    if (providerArg !== undefined) {
+        preference = parseLlmProviderPreference(providerArg);
+        if (preference === null) {
+            log.error(`Unknown provider "${providerArg}". Use auto, codex-oauth, cursor-agent, or openai.`);
+            process.exitCode = 1;
+            return;
+        }
+    }
+    else if (nonInteractive) {
+        log.error("Provider required in non-interactive mode: vibeops llm use <provider>");
+        process.exitCode = 1;
+        return;
+    }
+    else {
+        const probes = await probeAllLlmProviders(cwd);
+        const choices = [
+            { name: labelLlmProvider("auto"), value: "auto" },
+            ...probes.map((p) => ({
+                name: `${labelLlmProvider(p.id)}${p.ok ? "" : " (not connected)"}`,
+                value: p.id,
+                disabled: p.ok ? undefined : "Run vibeops llm connect first",
+            })),
+        ];
+        preference = await select({
+            message: "Default LLM for task add / task done",
+            choices,
+            loop: false,
+        });
+    }
+    await setLlmProviderPreference(cwd, preference);
+    log.ok(`LLM preference → ${labelLlmProvider(preference)}`);
+    const active = await resolveLlmProviderForUse(cwd, preference);
+    if (active === null && preference !== "auto") {
+        log.warn(`"${preference}" is not connected yet. Run ${cyan("vibeops llm connect")}.`);
+        printConnectSetupHint(preference);
+        process.exitCode = 1;
+    }
+    else if (active !== null) {
+        log.info(`  Active now: ${green(labelLlmProvider(active))}`);
+    }
+}
+export async function llmConnectCommand(opts = {}) {
+    const cwd = resolve(opts.cwd ?? process.cwd());
+    if (!(await requireProject(cwd)))
+        return;
+    const nonInteractive = opts.nonInteractive === true || process.stdin.isTTY !== true;
+    if (nonInteractive) {
+        log.error("llm connect requires an interactive terminal.");
+        process.exitCode = 1;
+        return;
+    }
+    log.info(bold("vibeops llm connect"));
+    log.info(dim("Set up providers, then pick which one task add / task done use."));
+    log.blank();
+    let done = false;
+    while (!done) {
+        const probes = await probeAllLlmProviders(cwd);
+        const config = await readConfig(cwd);
+        const pref = getLlmPreferenceFromConfig(config);
+        const active = await resolveLlmProviderForUse(cwd, pref);
+        log.info(bold("  Connected providers"));
+        for (const p of probes) {
+            log.info(`    ${p.ok ? green("✓") : dim("·")} ${p.id} — ${dim(p.summary)}`);
+        }
+        log.info(`  ${dim("Preferred")} ${labelLlmProvider(pref)} · ${dim("Active")} ${active ? labelLlmProvider(active) : yellow("none")}`);
+        log.blank();
+        const action = await select({
+            message: "LLM setup",
+            choices: [
+                { name: "Choose default provider (task add / task done)", value: "pick" },
+                { name: "Set up Cursor Agent CLI (`agent login`)", value: "setup-cursor" },
+                { name: "Show Codex OAuth setup (`codex login`)", value: "setup-codex" },
+                { name: "Set up OpenAI API key (.vibeops.env)", value: "setup-openai" },
+                { name: "Done", value: "done" },
+            ],
+            loop: false,
+        });
+        switch (action) {
+            case "pick": {
+                await llmUseCommand(undefined, { cwd });
+                break;
+            }
+            case "setup-cursor": {
+                const result = await runCursorAgentLogin(cwd);
+                if (result.ok)
+                    log.ok(result.message);
+                else {
+                    log.warn(result.message);
+                    process.exitCode = 1;
+                }
+                log.blank();
+                break;
+            }
+            case "setup-codex": {
+                const result = await guideCodexOAuth();
+                if (result.ok)
+                    log.ok(result.message);
+                else {
+                    for (const line of result.message.split("\n"))
+                        log.info(line);
+                }
+                log.blank();
+                break;
+            }
+            case "setup-openai": {
+                const key = await password({
+                    message: "OpenAI API key (stored in .vibeops.env, gitignored)",
+                    mask: "*",
+                    validate: (v) => (v.trim().length > 0 ? true : "Key is required"),
+                });
+                const result = await configureOpenAiKey(cwd, key);
+                if (result.ok)
+                    log.ok(result.message);
+                else
+                    log.warn(result.message);
+                log.blank();
+                break;
+            }
+            case "done":
+                done = true;
+                break;
+        }
+    }
+    const report = await buildLlmStatusReport(cwd);
+    const { activeLabel } = formatLlmStatusLine(report);
+    log.info(`Saved preference: ${labelLlmProvider(report.preference)} · Active: ${activeLabel}`);
+    log.info(`Check anytime: ${cyan("vibeops llm status")} or ${cyan("vibeops status")}`);
+}