@goodtek/vibeops 0.3.0 → 0.7.22

package/dist/commands/next.js

@@ -0,0 +1,283 @@
+import { resolve } from "node:path";
+import { ensureCursorImplementPrompt } from "../lib/cursor-task-prompt.js";
+import { readText } from "../lib/filesystem.js";
+import { doneCommand } from "./done.js";
+import { notionSyncCommand } from "./notion-sync.js";
+import { startCommand } from "./start.js";
+import { readConfig } from "../lib/config.js";
+import { pathExists } from "../lib/filesystem.js";
+import { popGuideHistory, pushGuideHistory, readGuideState, writeGuideState, } from "../lib/guide-state.js";
+import { askSelect, yesNoSelect } from "../lib/inquirer-helpers.js";
+import { bold, cyan, dim, green, log, yellow } from "../lib/logger.js";
+import { projectPaths } from "../lib/paths.js";
+import { statusDisplay } from "../lib/task.js";
+import { excerptDoneSummary, LAST_DONE_SUMMARY_REL, readLastDoneSummary, } from "../lib/mvp-done-summary.js";
+import { followUpStepId, guideStepRank, inferGuideStep, successorStepId, } from "../lib/workflow-guide.js";
+const MENU_NEXT_RUN = "Next — run suggested step";
+const MENU_NEXT_ADVANCE = "Next — check / advance step";
+const MENU_PREV = "Previous step";
+const MENU_REFRESH = "Refresh (re-detect from repo)";
+const MENU_QUIT = "Quit";
+async function renderPanel(ctx) {
+    const { step, task, gitBranch, gitDirty } = ctx;
+    log.blank();
+    log.info(bold("─".repeat(56)));
+    log.info(bold("  VibeOps · what's next"));
+    log.info(bold("─".repeat(56)));
+    if (task) {
+        log.info(`  ${dim("TASK")}     ${cyan(task.id)} — ${task.title || dim("(no title)")}`);
+        log.info(`  ${dim("Status")}  ${statusDisplay(task.status)}`);
+        if (gitBranch) {
+            log.info(`  ${dim("Git")}      ${gitBranch}${gitDirty === true ? yellow(" · dirty") : gitDirty === false ? green(" · clean") : ""}`);
+        }
+    }
+    else if (ctx.mode === "post-mvp" && ctx.referenceTask) {
+        log.info(`  ${dim("TASK")}     ${dim("(continue — last:")} ${cyan(ctx.referenceTask.id)} ${dim("done)")}`);
+    }
+    else if (ctx.mode === "post-mvp") {
+        log.info(`  ${dim("TASK")}     ${dim("(MVP complete — plan next slice)")}`);
+    }
+    else {
+        log.info(`  ${dim("TASK")}     ${dim("(none — run vibeops plan)")}`);
+    }
+    log.blank();
+    log.info(bold(`  Step: ${step.title}`));
+    for (const line of step.youDo)
+        log.info(`    ${dim("·")} ${line}`);
+    if (step.vibeopsCommand) {
+        log.blank();
+        log.info(`  ${dim("Command")}  ${cyan(step.vibeopsCommand)}`);
+    }
+    if (step.shellHints.length > 0) {
+        log.blank();
+        log.info(dim("  Shell:"));
+        for (const h of step.shellHints)
+            log.info(`    ${dim("$")} ${h}`);
+    }
+    log.info(bold("─".repeat(56)));
+    if (ctx.task && (step.id === "implement" || step.id === "commit")) {
+        const body = await readText(ctx.task.filePath);
+        const cursorPrompt = await ensureCursorImplementPrompt(ctx.cwd, ctx.config, ctx.task, body);
+        if (cursorPrompt !== null) {
+            log.blank();
+            log.info(bold("  Cursor"));
+            const missing = [];
+            if (cursorPrompt.fillResult)
+                missing.push("Result");
+            if (cursorPrompt.fillTestResult)
+                missing.push("Test Result");
+            log.info(`    ${dim("·")} ${missing.join(" / ")} not filled — start a chat and @-mention:`);
+            log.info(`      ${cyan(cursorPrompt.rel)}`);
+            log.info(`    ${dim("·")} Or open that file and send its contents as the first message.`);
+        }
+    }
+    const prior = await readLastDoneSummary(ctx.cwd);
+    if (prior !== null &&
+        (step.id === "no-mvp" ||
+            step.id === "all-done" ||
+            step.id === "continue-iteration" ||
+            task?.status === "done")) {
+        log.blank();
+        log.info(bold("  Previous iteration"));
+        for (const line of excerptDoneSummary(prior, 14).split("\n")) {
+            log.info(`    ${dim(line)}`);
+        }
+        log.info(`    ${dim("full")} ${cyan(LAST_DONE_SUMMARY_REL)}`);
+    }
+    log.blank();
+}
+async function runStep(ctx, step, dryRun, opts) {
+    if (dryRun && step.runnable) {
+        log.info(bold("dry-run — would run:"));
+        log.info(`  ${cyan(step.vibeopsCommand ?? step.title)}`);
+        return { ok: true, advancedTo: step.id };
+    }
+    switch (step.id) {
+        case "start":
+        case "checkout-task": {
+            const ref = ctx.task?.id ?? "mvp";
+            await startCommand(ref, { cwd: ctx.cwd, dryRun: false });
+            return { ok: process.exitCode !== 1, advancedTo: "implement" };
+        }
+        case "finish": {
+            const ref = ctx.task?.id ?? "mvp";
+            await doneCommand(ref, {
+                cwd: ctx.cwd,
+                dryRun: false,
+                mergeViaPr: opts.mergeViaPr,
+                allowDirty: opts.allowDirty,
+            });
+            return {
+                ok: process.exitCode !== 1,
+                advancedTo: ctx.mode === "mvp" ? "all-done" : undefined,
+            };
+        }
+        case "notion-sync":
+            await notionSyncCommand({ cwd: ctx.cwd, dryRun: false });
+            return { ok: process.exitCode !== 1, advancedTo: "all-done" };
+        default:
+            log.info(dim("Nothing to execute for this step."));
+            return { ok: true };
+    }
+}
+export async function nextCommand(options = {}) {
+    const cwd = resolve(options.cwd ?? process.cwd());
+    const paths = projectPaths(cwd);
+    if (!(await pathExists(paths.config))) {
+        log.error(`Not a VibeOps project. Run ${cyan("vibeops init")} first.`);
+        process.exitCode = 1;
+        return;
+    }
+    const config = await readConfig(paths.root);
+    let guideState = await readGuideState(paths.vibeopsDir);
+    /** Set only after "Previous step" — one-shot forced step for display. */
+    let forceStepOnce;
+    const loadContext = async (forceStepId) => {
+        const inferred = await inferGuideStep({ cwd, paths, config });
+        const taskKey = inferred.task?.id ?? inferred.referenceTask?.id ?? null;
+        const saved = forceStepOnce ??
+            (guideState?.taskId === taskKey &&
+                guideState.stepId &&
+                guideStepRank(guideState.stepId) > guideStepRank(inferred.step.id)
+                ? guideState.stepId
+                : undefined);
+        if (saved !== undefined && saved !== inferred.step.id) {
+            return inferGuideStep({ cwd, paths, config, forceStepId: saved });
+        }
+        return inferred;
+    };
+    const syncGuideStep = async (ctx) => {
+        if (forceStepOnce !== undefined)
+            return;
+        const taskKey = ctx.task?.id ?? ctx.referenceTask?.id ?? null;
+        if (guideState?.taskId === taskKey && guideState.stepId) {
+            if (guideStepRank(guideState.stepId) > guideStepRank(ctx.step.id))
+                return;
+        }
+        if (guideState?.stepId === ctx.step.id && guideState?.taskId === taskKey)
+            return;
+        guideState = pushGuideHistory(guideState, taskKey, ctx.step.id);
+        await writeGuideState(paths.vibeopsDir, guideState);
+    };
+    if (options.nonInteractive === true) {
+        const ctx = await loadContext(undefined);
+        await renderPanel(ctx);
+        if (options.execute === true && ctx.step.runnable) {
+            await runStep(ctx, ctx.step, options.dryRun === true, options);
+            if (ctx.task) {
+                await writeGuideState(paths.vibeopsDir, pushGuideHistory(guideState, ctx.task.id, ctx.step.id));
+            }
+        }
+        return;
+    }
+    if (!process.stdin.isTTY) {
+        const ctx = await loadContext(guideState?.stepId);
+        await renderPanel(ctx);
+        log.info(dim("Re-run in a terminal for the interactive menu."));
+        return;
+    }
+    for (;;) {
+        const ctx = await loadContext(forceStepOnce);
+        forceStepOnce = undefined;
+        await syncGuideStep(ctx);
+        await renderPanel(ctx);
+        const menuNext = ctx.step.runnable ? MENU_NEXT_RUN : MENU_NEXT_ADVANCE;
+        const picked = await askSelect({
+            message: "Choose",
+            nonInteractive: false,
+            choices: [menuNext, MENU_PREV, MENU_REFRESH, MENU_QUIT],
+            default: menuNext,
+        });
+        if (picked === MENU_QUIT) {
+            log.info(dim("Resume with: vibeops next"));
+            return;
+        }
+        if (picked === MENU_REFRESH) {
+            guideState = null;
+            continue;
+        }
+        if (picked === MENU_PREV) {
+            if (!guideState?.history.length) {
+                log.warn("No previous step in .vibeops/state/guide.json");
+                continue;
+            }
+            const popped = popGuideHistory(guideState);
+            guideState = popped.next;
+            if (popped.stepId)
+                forceStepOnce = popped.stepId;
+            continue;
+        }
+        const step = ctx.step;
+        if (!step.runnable) {
+            const body = ctx.task ? await readText(ctx.task.filePath) : "";
+            const fresh = await loadContext(undefined);
+            if (fresh.task?.id !== ctx.task?.id && ctx.task) {
+                log.warn(`Still on ${ctx.gitBranch ?? "task branch"} for ${ctx.task.id}. Run ${cyan(`vibeops done ${ctx.task.id}`)} (commit, merge, Notion) before starting ${fresh.task?.id ?? "another TASK"}.`);
+                continue;
+            }
+            if (fresh.step.runnable && fresh.step.id !== step.id) {
+                log.ok(`Step updated: ${bold(fresh.step.title)}`);
+                const go = await yesNoSelect({
+                    message: `Run: ${fresh.step.vibeopsCommand ?? fresh.step.title}?`,
+                    defaultValue: true,
+                });
+                if (!go)
+                    continue;
+                const result = await runStep(fresh, fresh.step, options.dryRun === true, options);
+                if (!result.ok) {
+                    log.warn("Step failed — fix the issue, then Refresh.");
+                    continue;
+                }
+                const nextId = result.advancedTo ?? followUpStepId(fresh.step.id);
+                if (nextId !== null && nextId !== undefined) {
+                    guideState = pushGuideHistory(guideState, fresh.task?.id ?? fresh.referenceTask?.id ?? null, nextId);
+                    await writeGuideState(paths.vibeopsDir, guideState);
+                }
+                else {
+                    guideState = null;
+                }
+                guideState = await readGuideState(paths.vibeopsDir);
+                log.ok("Done.");
+                log.blank();
+                continue;
+            }
+            const succ = successorStepId(step.id, { body, gitDirty: ctx.gitDirty });
+            if (succ !== null && succ !== step.id) {
+                const go = await yesNoSelect({
+                    message: `Move to next step (${succ})?`,
+                    defaultValue: true,
+                });
+                if (!go)
+                    continue;
+                guideState = pushGuideHistory(guideState, ctx.task?.id ?? null, succ);
+                await writeGuideState(paths.vibeopsDir, guideState);
+                log.ok(`Advanced to ${succ}.`);
+                log.blank();
+                continue;
+            }
+            log.info(dim("This step is manual (Cursor / git). Fill Result and Test Result, then choose Next again or Refresh."));
+            continue;
+        }
+        const go = await yesNoSelect({
+            message: `Run: ${step.vibeopsCommand ?? step.title}?`,
+            defaultValue: true,
+        });
+        if (!go)
+            continue;
+        const result = await runStep(ctx, step, options.dryRun === true, options);
+        if (!result.ok) {
+            log.warn("Step failed — fix the issue, then Refresh.");
+            continue;
+        }
+        const nextId = result.advancedTo ?? followUpStepId(step.id);
+        if (nextId !== null && nextId !== undefined) {
+            await writeGuideState(paths.vibeopsDir, pushGuideHistory(guideState, ctx.task?.id ?? ctx.referenceTask?.id ?? null, nextId));
+        }
+        else {
+            guideState = null;
+        }
+        guideState = await readGuideState(paths.vibeopsDir);
+        log.ok(`Done. Refresh or Next for the following step.`);
+        log.blank();
+    }
+}

package/dist/commands/plan.js

@@ -1,16 +1,14 @@
 import { isAbsolute, join, relative, resolve } from "node:path";
 import { briefToMarkdown, findMissingRequired, gatherBrief, parseBriefFromMarkdown, parseIdea, } from "../lib/brief.js";
-import { askYesNo } from "../lib/inquirer-helpers.js";
 import { pathExists, readText, writeText } from "../lib/filesystem.js";
 import { bold, cyan, dim, log, yellow } from "../lib/logger.js";
-import { applyPlannerMarkdownFlow, commitPlannerGit, pushPlannerGit } from "../lib/plan-apply-planner.js";
 import { gatherBriefViaLlm, pickPlanDialogueLocale, pickPlanLlmProvider } from "../lib/plan-llm-session.js";
 import { pickPlanExecutionModel } from "../lib/plan-llm-models.js";
-import { ensureGitForPlannerCommit, offerGithubInitBeforePush, runNotionSyncWithOptionalInit } from "../lib/plan-post-apply-setup.js";
-import { buildPlanPrompt } from "../lib/prompt-builder.js";
+import { writeMvpArtifacts } from "../lib/mvp-artifacts.js";
+import { LAST_DONE_SUMMARY_REL, readLastDoneSummary } from "../lib/mvp-done-summary.js";
+import { MVP_BUILD_PROMPT_REL } from "../lib/mvp-constants.js";
 import { projectPaths } from "../lib/paths.js";
 const DEFAULT_BRIEF_REL = ".vibeops/brief/project-brief.md";
-const DEFAULT_PROMPT_REL = ".vibeops/generated/plan-prompt.md";
 function toAbsolute(root, candidate) {
     return isAbsolute(candidate) ? candidate : resolve(root, candidate);
 }
@@ -18,7 +16,7 @@ function relDisplay(root, abs) {
     const r = relative(root, abs);
     return r.length === 0 ? "." : r;
 }
-export async function planCommand(options) {
+export async function planCommand(options = {}) {
     const cwd = resolve(options.cwd ?? process.cwd());
     const nonInteractive = options.nonInteractive === true;
     const paths = projectPaths(cwd);
@@ -29,7 +27,6 @@ export async function planCommand(options) {
         return;
     }
     const briefAbs = join(cwd, DEFAULT_BRIEF_REL);
-    const promptAbs = typeof options.output === "string" ? toAbsolute(cwd, options.output) : join(cwd, DEFAULT_PROMPT_REL);
     log.info(bold(`vibeops plan`));
     log.info(dim(`  cwd: ${cwd}`));
     if (options.from)
@@ -43,8 +40,6 @@ export async function planCommand(options) {
         log.info(dim(`  mode: non-interactive`));
     log.blank();
     let bundle;
-    let llmProviderForApply;
-    let llmModelForApply;
     if (typeof options.from === "string" && options.from.length > 0) {
         bundle = await loadFromFile({
             cwd,
@@ -53,255 +48,69 @@ export async function planCommand(options) {
             idea: options.idea,
         });
     }
+    else if (nonInteractive) {
+        log.step("non-interactive: build ProjectBrief from flags + placeholders");
+        log.blank();
+        bundle = await gatherBrief({ cwd, idea: options.idea, nonInteractive: true });
+    }
     else {
-        if (!nonInteractive && process.stdin.isTTY !== true) {
-            log.error("vibeops plan requires a TTY. In CI/piped environments, pass --non-interactive or supply --from <brief.md>.");
+        if (process.stdin.isTTY !== true) {
+            log.error("vibeops plan requires a TTY. In CI, pass --non-interactive or --from <brief.md>.");
             process.exitCode = 1;
             return;
         }
-        if (nonInteractive) {
-            log.step("non-interactive: build the ProjectBrief from flag values + safe placeholders");
-            log.blank();
-            bundle = await gatherBrief({
-                cwd,
-                idea: options.idea,
-                nonInteractive: true,
-            });
-        }
-        else if (options.legacyWizard === true) {
-            log.step("legacy wizard: build the ProjectBrief from 20 fixed questions (arrow keys · Space · Enter)");
-            log.blank();
-            bundle = await gatherBrief({
-                cwd,
-                idea: options.idea,
-                nonInteractive: false,
-                legacyWizard: true,
-            });
-        }
-        else {
-            log.step("LLM planning: verify provider, then interactive discovery + structured brief");
-            log.blank();
-            const interactiveLogin = process.stdin.isTTY === true;
-            const provider = await pickPlanLlmProvider(cwd, options.provider, { interactiveLogin });
-            if (provider === null) {
-                return;
-            }
-            const forcedModel = typeof options.llmModel === "string" && options.llmModel.trim().length > 0
-                ? options.llmModel.trim()
-                : undefined;
-            const pickedModel = forcedModel ??
-                (await pickPlanExecutionModel({
-                    provider,
-                    cwd,
-                    interactive: interactiveLogin,
-                }));
-            log.blank();
-            const planningLocale = await pickPlanDialogueLocale();
-            try {
-                bundle = await gatherBriefViaLlm({
-                    cwd,
-                    idea: options.idea,
-                    provider,
-                    allowCodexBrowserLogin: interactiveLogin,
-                    llmModelOverride: pickedModel,
-                    planningLocale,
-                });
-                llmProviderForApply = provider;
-                llmModelForApply =
-                    typeof pickedModel === "string" && pickedModel.trim().length > 0 ? pickedModel.trim() : undefined;
-            }
-            catch (e) {
-                const msg = e instanceof Error ? e.message : String(e);
-                log.error(`LLM planning failed: ${msg}`);
-                process.exitCode = 1;
-                return;
-            }
-        }
-    }
-    const briefMd = briefToMarkdown(bundle.brief, bundle.meta);
-    await writeText(briefAbs, briefMd);
-    log.ok(`Wrote brief: ${relDisplay(cwd, briefAbs)}`);
-    const promptMd = buildPlanPrompt({
-        brief: bundle.brief,
-        meta: bundle.meta,
-        briefRelativePath: relDisplay(cwd, briefAbs),
-    });
-    await writeText(promptAbs, promptMd);
-    log.ok(`Cursor planning prompt: ${relDisplay(cwd, promptAbs)}`);
-    if (bundle.meta.assumptions.length > 0) {
+        log.step("LLM planning: interactive discovery → brief + MVP artifacts");
         log.blank();
-        log.info(`${yellow("!")} ${bold("Assumptions")} (items the Planner Agent should reconfirm):`);
-        for (const a of bundle.meta.assumptions)
-            log.info(`  · ${a}`);
-    }
-    const wantsApply = options.applyPlanner === true || options.applyPlannerDryRun === true;
-    if (wantsApply) {
-        const applyDryRun = options.applyPlannerDryRun === true;
-        const exec = await resolvePlannerApplyExecution({
-            cwd,
-            nonInteractive,
-            fromLlmProvider: llmProviderForApply,
-            fromLlmModel: llmModelForApply,
-            cliProvider: options.provider,
-            cliModel: options.llmModel,
-        });
-        if (exec === null) {
+        const interactiveLogin = true;
+        const provider = await pickPlanLlmProvider(cwd, options.provider, { interactiveLogin });
+        if (provider === null)
             return;
-        }
+        const forcedModel = typeof options.llmModel === "string" && options.llmModel.trim().length > 0
+            ? options.llmModel.trim()
+            : undefined;
+        const pickedModel = forcedModel ??
+            (await pickPlanExecutionModel({ provider, cwd, interactive: interactiveLogin }));
+        log.blank();
+        const planningLocale = await pickPlanDialogueLocale();
         try {
-            const applyResult = await applyPlannerMarkdownFlow({
+            bundle = await gatherBriefViaLlm({
                 cwd,
-                planPromptMarkdown: promptMd,
-                provider: exec.provider,
-                model: exec.model,
-                dryRun: applyDryRun,
+                idea: options.idea,
+                provider,
+                allowCodexBrowserLogin: interactiveLogin,
+                llmModelOverride: pickedModel,
+                planningLocale,
             });
-            const applyInteractive = !nonInteractive && process.stdin.isTTY === true && !applyDryRun;
-            const hasWrittenFiles = !applyDryRun && applyResult.writtenRelativePaths.length > 0;
-            let doCommit = hasWrittenFiles && options.noGitCommit !== true;
-            if (doCommit && applyInteractive) {
-                log.blank();
-                log.step("Next: commit, push, and Notion (confirm each step)");
-                doCommit = await askYesNo({
-                    message: "[1] Create a git commit for the planner output (docs/project + docs/tasks)?",
-                    nonInteractive: false,
-                    defaultValue: true,
-                });
-            }
-            let committedOk = false;
-            if (doCommit) {
-                const gitReady = await ensureGitForPlannerCommit({
-                    cwd,
-                    interactive: applyInteractive,
-                });
-                if (!gitReady) {
-                    doCommit = false;
-                }
-            }
-            if (doCommit) {
-                try {
-                    await commitPlannerGit(cwd, applyResult.writtenRelativePaths, "docs: planner output from vibeops plan (--apply-planner)");
-                    log.ok("Git commit created for planner docs/tasks.");
-                    committedOk = true;
-                }
-                catch (e) {
-                    const msg = e instanceof Error ? e.message : String(e);
-                    log.warn(`Git commit did not run (${msg}). Review changes and commit manually.`);
-                }
-            }
-            let doPush = false;
-            if (committedOk) {
-                if (options.gitPush === true) {
-                    doPush = true;
-                }
-                else if (applyInteractive) {
-                    doPush = await askYesNo({
-                        message: "[2] Push this commit to the remote (git push)? (If Yes, you may be offered `vibeops github init` to connect or create a GitHub repo / set `origin`.)",
-                        nonInteractive: false,
-                        defaultValue: false,
-                    });
-                }
-                if (doPush) {
-                    await offerGithubInitBeforePush({ cwd, interactive: applyInteractive });
-                    try {
-                        await pushPlannerGit(cwd);
-                        log.ok("git push complete.");
-                    }
-                    catch (e) {
-                        const msg = e instanceof Error ? e.message : String(e);
-                        log.error(`git push failed: ${msg}`);
-                        process.exitCode = 1;
-                    }
-                }
-            }
-            else if (options.gitPush === true && !committedOk) {
-                log.warn("`--push` skipped (no successful commit: dry-run, --no-git-commit, you declined the commit prompt, commit error, or no files written).");
-            }
-            let doNotion = bundle.brief.useNotion === true && options.noNotionSync !== true && !applyDryRun;
-            if (doNotion && applyInteractive) {
-                doNotion = await askYesNo({
-                    message: "[3] Run Notion sync now (project + TASK metadata)?",
-                    nonInteractive: false,
-                    defaultValue: true,
-                });
-            }
-            if (doNotion) {
-                const hadErrBeforeNotion = process.exitCode === 1;
-                await runNotionSyncWithOptionalInit({ cwd, interactive: applyInteractive });
-                if (hadErrBeforeNotion) {
-                    process.exitCode = 1;
-                }
-                if (process.exitCode === 1 && !hadErrBeforeNotion) {
-                    log.warn("Notion sync failed — fix integration and run `vibeops notion sync`.");
-                }
-            }
-            else if (bundle.brief.useNotion === true && applyDryRun) {
-                log.info(dim("Notion sync skipped for --apply-dry-run."));
-            }
-            else if (bundle.brief.useNotion === true && options.noNotionSync === true) {
-                log.info(dim("Notion sync skipped (--no-notion-sync)."));
-            }
-            else if (bundle.brief.useNotion === true && applyInteractive && !doNotion) {
-                log.info(dim("Notion sync skipped (you chose No)."));
-            }
         }
         catch (e) {
             const msg = e instanceof Error ? e.message : String(e);
-            log.error(`Planner apply failed: ${msg}`);
+            log.error(`LLM planning failed: ${msg}`);
             process.exitCode = 1;
             return;
         }
     }
-    log.blank();
-    log.info(bold("Next steps:"));
-    if (wantsApply && options.applyPlannerDryRun !== true) {
-        log.info(`  1) Open this repo in Cursor and run ${cyan("vibeops task start TASK-NNN")} for each backlog item.`);
-        log.info(`  2) The planning prompt is still at ${cyan(relDisplay(cwd, promptAbs))} if you need to re-run the planner.`);
-        log.info(`  3) To revise the brief only, edit ${cyan(relDisplay(cwd, briefAbs))} then:`);
-        log.info(`     ${dim("vibeops plan --from " + DEFAULT_BRIEF_REL + " [--apply-planner …]")}`);
-    }
-    else if (wantsApply && options.applyPlannerDryRun === true) {
-        log.info(`  1) Re-run without ${cyan("--apply-dry-run")} to write files, commit, and (if enabled) Notion sync.`);
-        log.info(`  2) Or paste ${cyan(relDisplay(cwd, promptAbs))} into Cursor for a manual planner pass.`);
-    }
-    else {
-        log.info(`  1) Open a new Cursor chat and paste the full contents of ${cyan(relDisplay(cwd, promptAbs))}.`);
-        log.info(`  2) Or run again with ${cyan("--apply-planner")}: the CLI calls the same LLM and writes ${cyan("docs/project/*")} + ${cyan("docs/tasks/*")} from the prompt (brief alone does not create TASK files).`);
-        log.info(`  3) Regenerate only the prompt from an edited brief:`);
-        log.info(`     ${dim("vibeops plan --from " + DEFAULT_BRIEF_REL + " [--apply-planner …]")}`);
-    }
-}
-async function resolvePlannerApplyExecution(inputs) {
-    if (inputs.fromLlmProvider !== undefined) {
-        return { provider: inputs.fromLlmProvider, model: inputs.fromLlmModel };
-    }
-    const tty = process.stdin.isTTY === true;
-    if (inputs.cliProvider !== undefined) {
-        const interactiveLogin = tty && !inputs.nonInteractive;
-        const provider = await pickPlanLlmProvider(inputs.cwd, inputs.cliProvider, { interactiveLogin });
-        if (provider === null)
-            return null;
-        let model = inputs.cliModel?.trim();
-        if (!model && tty && !inputs.nonInteractive) {
-            const picked = await pickPlanExecutionModel({
-                provider,
-                cwd: inputs.cwd,
-                interactive: true,
-            });
-            model = picked?.trim();
-        }
-        return { provider, model: model && model.length > 0 ? model : undefined };
+    await writeText(briefAbs, briefToMarkdown(bundle.brief, bundle.meta));
+    log.ok(`Wrote brief: ${relDisplay(cwd, briefAbs)}`);
+    const prior = await readLastDoneSummary(cwd);
+    if (prior !== null) {
+        log.info(dim(`  prior iteration: ${LAST_DONE_SUMMARY_REL} → included in TASK + mvp-build.md`));
     }
-    if (!tty || inputs.nonInteractive) {
-        log.error("When using --apply-planner without an interactive LLM briefing in the same run, pass --provider openai | codex-oauth | cursor-agent (and optional --model / env defaults).");
-        process.exitCode = 1;
-        return null;
+    const mvp = await writeMvpArtifacts(cwd, bundle);
+    log.ok(`MVP TASK: ${relDisplay(cwd, mvp.taskFile)}`);
+    log.ok(`MVP build prompt: ${relDisplay(cwd, mvp.buildPromptFile)}`);
+    if (bundle.meta.assumptions.length > 0) {
+        log.blank();
+        log.info(`${yellow("!")} ${bold("Assumptions")} (reconfirm in Cursor if needed):`);
+        for (const a of bundle.meta.assumptions)
+            log.info(`  · ${a}`);
     }
-    const provider = await pickPlanLlmProvider(inputs.cwd, undefined, { interactiveLogin: true });
-    if (provider === null)
-        return null;
-    const model = await pickPlanExecutionModel({ provider, cwd: inputs.cwd, interactive: true });
-    return { provider, model };
+    log.blank();
+    log.info(bold("Next steps:"));
+    log.info(`  1) ${cyan("vibeops start")}`);
+    log.info(`  2) Drag ${cyan(MVP_BUILD_PROMPT_REL)} into a new Cursor chat`);
+    log.info(`  3) ${cyan("vibeops done")} when Result / Test Result are filled`);
+    log.info(`  4) ${cyan("vibeops next")} for step-by-step guidance`);
+    log.info(dim(`Re-plan from brief: vibeops plan --from ${DEFAULT_BRIEF_REL}`));
 }
 async function loadFromFile(inputs) {
     const { cwd, fromPath, nonInteractive, idea } = inputs;
@@ -323,21 +132,15 @@ async function loadFromFile(inputs) {
         }
     }
     const missing = findMissingRequired(parsed.brief);
-    if (missing.length === 0) {
+    if (missing.length === 0)
         return parsed;
-    }
     if (nonInteractive) {
-        log.warn(`Missing required fields: ${missing.join(", ")} → filling with placeholders and recording them in Assumptions.`);
+        log.warn(`Missing fields: ${missing.join(", ")} — placeholders recorded in Assumptions.`);
         return parsed;
     }
-    log.warn(`Missing required fields: ${missing.join(", ")} → asking only the missing questions.`);
+    log.warn(`Missing fields: ${missing.join(", ")} — asking only those questions.`);
     log.blank();
-    const filled = await gatherBrief({
-        cwd,
-        idea,
-        nonInteractive: false,
-        seed: parsed.brief,
-    });
+    const filled = await gatherBrief({ cwd, idea, nonInteractive: false, seed: parsed.brief });
     filled.meta.source = "from-file";
     return filled;
 }