@goodtek/vibeops 0.7.22 → 1.0.0

package/dist/cli.js

@@ -1,34 +1,23 @@
 #!/usr/bin/env node
 import { Command } from "commander";
-import { doneCommand } from "./commands/done.js";
-import { githubInitCommand } from "./commands/github-init.js";
-import { githubStatusCommand } from "./commands/github-status.js";
 import { initCommand } from "./commands/init.js";
-import { nextCommand } from "./commands/next.js";
-import { notionInitCommand } from "./commands/notion-init.js";
-import { notionSyncCommand } from "./commands/notion-sync.js";
-import { notionTestCommand } from "./commands/notion-test.js";
-import { planCommand } from "./commands/plan.js";
-import { rollbackCommand } from "./commands/rollback.js";
-import { startCommand } from "./commands/start.js";
 import { statusCommand } from "./commands/status.js";
 import { taskAddCommand } from "./commands/task-add.js";
-import { taskStatusCommand } from "./commands/task-status.js";
+import { taskDoneCommand } from "./commands/task-done.js";
 import { VERSION } from "./version.js";
 const program = new Command();
 program
     .name("vibeops")
-    .description("VibeOps — plan an MVP, build in Cursor (drag mvp-build.md), finish with Git rails.\n" +
-    "  Commands: init · plan · start · done · next · status · task add · task status (+ optional notion · github · rollback)")
+    .description("VibeOps v3 — Cursor-friendly TASK workflow (init · task add · task done · status)")
     .version(VERSION, "-v, --version", "Print the VibeOps version");
 program
     .command("init")
-    .description("Install the VibeOps workflow into the current directory")
-    .option("--dry-run", "Show what would be created without writing files")
+    .description("Install the VibeOps v3 project tree")
+    .option("--dry-run", "Show what would be created")
     .option("--force", "Overwrite existing files")
     .option("--cwd <path>", "Target directory")
     .option("--name <projectName>", "Project name in .vibeops.json")
-    .option("--git", "Initialize Git without prompting")
+    .option("--git", "Initialize Git")
     .option("--no-git", "Skip Git")
     .option("--initial-commit", "Create initial commit")
     .option("--no-initial-commit", "Skip initial commit")
@@ -37,80 +26,13 @@ program
     .action(async (opts) => {
     await initCommand(opts);
 });
-program
-    .command("plan")
-    .description("LLM planning → brief + TASK-mvp + .vibeops/generated/mvp-build.md")
-    .option("--idea <text>", "One-line idea (optional Name: idea prefix)")
-    .option("--from <path>", "Regenerate MVP artifacts from an existing brief")
-    .option("--non-interactive", "Placeholders only (CI); no LLM")
-    .option("--provider <id>", "openai | codex-oauth | cursor-agent")
-    .option("--model <id>", "LLM model id")
-    .option("--cwd <path>", "Target directory")
-    .action(async (opts) => {
-    const provider = opts.provider === "openai" ||
-        opts.provider === "codex-oauth" ||
-        opts.provider === "cursor-agent"
-        ? opts.provider
-        : undefined;
-    await planCommand({
-        idea: opts.idea,
-        from: opts.from,
-        nonInteractive: opts.nonInteractive,
-        provider,
-        llmModel: opts.model,
-        cwd: opts.cwd,
-    });
-});
-program
-    .command("start [taskRef]")
-    .description("Create task branch (default: TASK-mvp, or active backlog TASK if no MVP file)")
-    .option("--dry-run", "Show plan only")
-    .option("--allow-dirty", "Allow dirty working tree")
-    .option("--cwd <path>", "Target directory")
-    .action(async (taskRef, opts) => {
-    await startCommand(taskRef, opts);
-});
-program
-    .command("done [taskRef]")
-    .description("Finish TASK: auto-fill Result/Test Result + summary md, merge to main, Notion sync (default: TASK-mvp or active backlog)")
-    .option("--dry-run", "Show plan only")
-    .option("--no-merge", "Skip push / merge / branch delete")
-    .option("--skip-summary", "Skip last-done-summary.md and TASK auto-fill")
-    .option("--refresh-task-sections", "Overwrite existing Result / Test Result")
-    .option("--merge-via-pr", "Merge via gh PR")
-    .option("--allow-dirty", "Allow dirty tree during merge")
-    .option("--no-notion-sync", "Skip automatic Notion sync after done")
-    .option("--cwd <path>", "Target directory")
-    .action(async (taskRef, opts) => {
-    await doneCommand(taskRef, opts);
-});
-program
-    .command("next")
-    .description("Interactive guide for the MVP workflow (↑/↓ · Yes/No)")
-    .option("--dry-run", "On runnable steps, print only")
-    .option("--non-interactive", "Print panel once")
-    .option("--execute", "With --non-interactive, run the runnable step once")
-    .option("--merge-via-pr", "On finish: merge via GitHub PR")
-    .option("--allow-dirty", "Allow dirty tree on merge")
-    .option("--cwd <path>", "Target directory")
-    .action(async (opts) => {
-    await nextCommand(opts);
-});
-program
-    .command("status")
-    .description("Installation, TASK-mvp state, Git, Notion, GitHub")
-    .option("--json", "JSON output")
-    .option("--cwd <path>", "Target directory")
-    .action(async (opts) => {
-    await statusCommand(opts);
-});
-const task = program.command("task").description("Backlog TASK files");
+const task = program.command("task").description("TASK lifecycle");
 task
     .command("add")
-    .description("Interactive: close open TASK (optional), create next TASK-NNN, branch checkout, In Progress")
-    .option("--dry-run", "Show plan only (no writes, no LLM planning session)")
-    .option("--non-interactive", "CI: minimal scaffold without prompts (optional --idea)")
-    .option("--idea <text>", "Short description (CI / smoke only)")
+    .description("Create next TASK-NNN, task branch, In Progress (guide-only if one is open)")
+    .option("--dry-run", "Plan only")
+    .option("--non-interactive", "CI: minimal scaffold (optional --idea)")
+    .option("--idea <text>", "Short description (CI)")
     .option("--cwd <path>", "Target directory")
     .action(async (opts) => {
     await taskAddCommand({
@@ -121,87 +43,31 @@ task
     });
 });
 task
-    .command("status")
-    .description("Briefing on current TASK progress and recommended next step")
-    .option("--json", "JSON output")
+    .command("done [taskRef]")
+    .description("Close TASK: LLM summary, project memory, merge")
+    .option("--dry-run", "Plan only")
+    .option("--no-merge", "Skip merge")
+    .option("--allow-dirty", "Allow dirty tree during merge")
+    .option("--yes", "Merge without prompting")
     .option("--cwd <path>", "Target directory")
-    .action(async (opts) => {
-    await taskStatusCommand({
-        json: Boolean(opts.json),
+    .action(async (taskRef, opts) => {
+    await taskDoneCommand(taskRef, {
+        dryRun: Boolean(opts.dryRun),
+        noMerge: Boolean(opts.noMerge),
+        allowDirty: Boolean(opts.allowDirty),
+        yes: Boolean(opts.yes),
         cwd: opts.cwd,
     });
 });
 program
-    .command("rollback [taskRef]")
-    .description("Advisory rollback for TASK-mvp (--confirm / --confirm-destructive to execute)")
-    .option("--confirm", "Run non-destructive rollback")
-    .option("--confirm-destructive", "Allow destructive rollback (reset --hard)")
-    .option("--strategy <name>", "branch-delete | reset-base | revert-merge")
-    .option("--keep-branch", "Keep task branch when deleting")
-    .option("--dry-run", "Print plan only")
-    .option("--cwd <path>", "Target directory")
-    .action(async (taskRef, opts) => {
-    await rollbackCommand(taskRef, opts);
-});
-const notion = program.command("notion").description("Optional Notion dashboard sync");
-notion
-    .command("init")
-    .description("Configure Notion in .vibeops.json and .vibeops.env")
-    .option("--dry-run", "Plan only")
-    .option("--enable", "Enable Notion")
-    .option("--projects-db <id>", "Projects database id")
-    .option("--tasks-db <id>", "Tasks database id")
-    .option("--non-interactive", "No prompts")
-    .option("--cwd <path>", "Target directory")
-    .action(async (opts) => {
-    await notionInitCommand(opts);
-});
-notion
-    .command("test")
-    .description("Verify Notion token and database schema")
-    .option("--json", "JSON output")
-    .option("--debug-shape", "Print API shape diagnostics")
-    .option("--cwd <path>", "Target directory")
-    .action(async (opts) => {
-    await notionTestCommand(opts);
-});
-notion
-    .command("sync")
-    .description("Push docs/project + TASK metadata to Notion")
-    .option("--dry-run", "Query only")
-    .option("--json", "JSON output")
-    .option("--only-tasks", "Tasks DB only")
-    .option("--only-project", "Project DB only")
-    .option("--cwd <path>", "Target directory")
-    .action(async (opts) => {
-    await notionSyncCommand(opts);
-});
-const github = program.command("github").description("Optional GitHub remote setup");
-github
     .command("status")
-    .description("gh auth, remotes, .vibeops.json github section")
+    .description("Briefing: active TASK, Git, next hint")
     .option("--json", "JSON output")
     .option("--cwd <path>", "Target directory")
     .action(async (opts) => {
-    await githubStatusCommand(opts);
-});
-github
-    .command("init")
-    .description("Connect or create a GitHub repo and update config")
-    .option("--dry-run", "Plan only")
-    .option("--yes", "Non-interactive defaults")
-    .option("--owner <owner>", "GitHub owner")
-    .option("--repo <repo>", "Repo name")
-    .option("--public", "Public repo")
-    .option("--private", "Private repo")
-    .option("--remote <name>", "Remote name (default origin)")
-    .option("--connect <ownerOrUrl>", "Existing repo")
-    .option("--no-package-update", "Skip package.json repo fields")
-    .option("--cwd <path>", "Target directory")
-    .action(async (opts) => {
-    await githubInitCommand({
-        ...opts,
-        noPackageUpdate: opts.packageUpdate === false,
+    await statusCommand({
+        json: Boolean(opts.json),
+        cwd: opts.cwd,
     });
 });
 program.parseAsync(process.argv).catch((err) => {

package/dist/commands/init.js

@@ -34,9 +34,9 @@ export async function initCommand(options = {}) {
     if (!dryRun) {
         log.blank();
         log.info("Next steps:");
-        log.info("  1. Open AGENTS.md and confirm the project name.");
-        log.info("  2. Run `vibeops status` to verify installation.");
-        log.info("  3. Run `vibeops plan` to populate docs/project/* (or fill them by hand).");
+        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) {

package/dist/commands/status.js

@@ -1,12 +1,149 @@
 import { resolve } from "node:path";
-import { collectStatus } from "../status/collector.js";
-import { printHuman, toJson } from "../status/format.js";
-import { log } from "../lib/logger.js";
-export async function statusCommand(options = {}) {
-    const cwd = resolve(options.cwd ?? process.cwd());
-    const report = await collectStatus(cwd);
-    if (options.json) {
-        log.raw(toJson(report));
+import { readConfig } from "../lib/config.js";
+import { readText } from "../lib/filesystem.js";
+import { readGitInfo } from "../lib/git.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 { countTasks, hasNonEmptySection, isOnTaskBranch, loadActionableTasks, readGitContext, statusDisplay } from "../lib/task.js";
+import { summarizeGoal } from "../lib/task-summary.js";
+async function buildReport(cwd) {
+    const paths = projectPaths(cwd);
+    const config = await readConfig(cwd);
+    const git = await readGitInfo(cwd);
+    const isVibeopsProject = config !== null;
+    let counts = null;
+    let inProgress = [];
+    let focus = null;
+    if (isVibeopsProject) {
+        const tasks = await loadActionableTasks(paths.docsTasks);
+        counts = countTasks(tasks);
+        inProgress = await listInProgressTasks(paths);
+        focus = await pickFocusTask(paths, cwd);
+    }
+    let focusBlock = null;
+    let resultFilled = false;
+    let testFilled = false;
+    let onTaskBranch = null;
+    let taskBranch = null;
+    let branchExists = null;
+    let goalExcerpt = "";
+    if (focus !== null) {
+        const body = await readText(focus.filePath);
+        goalExcerpt = summarizeGoal(body);
+        resultFilled = hasNonEmptySection(body, "Result");
+        testFilled = hasNonEmptySection(body, "Test Result");
+        const ctx = await readGitContext(focus.filePath);
+        taskBranch = ctx?.taskBranch ?? null;
+        onTaskBranch = isOnTaskBranch(git.branch, ctx);
+        branchExists = await taskBranchExistsFor(cwd, focus);
+        focusBlock = {
+            id: focus.id,
+            title: focus.title,
+            status: statusDisplay(focus.status),
+            file: relPath(cwd, focus.filePath),
+            goalExcerpt,
+            resultFilled,
+            testResultFilled: testFilled,
+            onTaskBranch,
+            taskBranch,
+            taskBranchExists: branchExists,
+        };
+    }
+    const hint = computeNextHint({
+        isVibeopsProject,
+        focus,
+        resultFilled,
+        testFilled,
+        onTaskBranch,
+    });
+    return {
+        vibeopsVersion: VERSION,
+        isVibeopsProject,
+        projectName: config?.name ?? null,
+        git: {
+            isRepo: git.isRepo,
+            branch: git.branch,
+            dirty: git.dirty,
+        },
+        counts,
+        inProgress: inProgress.map((t) => ({
+            id: t.id,
+            title: t.title,
+            file: relPath(cwd, t.filePath),
+        })),
+        focus: focusBlock,
+        nextHint: hintToText(hint, cwd, focus),
+    };
+}
+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}`);
+    if (!report.isVibeopsProject) {
+        log.info(`  ${dim("Project")}  ${yellow("not initialized")} — run vibeops init`);
+        log.info(bold("─".repeat(56)));
+        log.blank();
+        return;
+    }
+    log.info(`  ${dim("Project")}  ${report.projectName ?? "(unnamed)"}`);
+    if (report.counts) {
+        const c = report.counts;
+        log.info(`  ${dim("Tasks")}    ${c.total} total · ${cyan(String(c.in_progress))} in progress · ${c.done} done`);
+    }
+    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")}`);
+    }
+    else {
+        log.info(`  ${dim("Focus")}    ${dim("(none)")}`);
+    }
+    log.blank();
+    log.info(bold("  Git"));
+    if (!report.git.isRepo) {
+        log.info(`    ${yellow("not a git repository")}`);
+    }
+    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.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}`);
+        }
+    }
+    log.blank();
+    log.info(`${dim("Next")}     ${report.nextHint}`);
+    log.info(bold("─".repeat(56)));
+    log.blank();
+}
+export async function statusCommand(opts = {}) {
+    const cwd = resolve(opts.cwd ?? process.cwd());
+    const report = await buildReport(cwd);
+    if (opts.json) {
+        log.raw(JSON.stringify(report, null, 2));
     }
     else {
         printHuman(report);

package/dist/commands/task-add.js

@@ -1,200 +1,100 @@
-import { mkdir } from "node:fs/promises";
-import { join, relative, resolve } from "node:path";
-import { doneCommand } from "./done.js";
-import { startCommand } from "./start.js";
+import { resolve } from "node:path";
 import { pathExists, writeText } from "../lib/filesystem.js";
-import { bold, cyan, dim, log } from "../lib/logger.js";
-import { askInput, askSelect, yesNoSelect } from "../lib/inquirer-helpers.js";
+import { askInput } from "../lib/inquirer-helpers.js";
+import { bold, cyan, dim, log, yellow } from "../lib/logger.js";
 import { projectPaths } from "../lib/paths.js";
 import { readConfig } from "../lib/config.js";
 import { slugify } from "../lib/slug.js";
-import { defaultBuildPromptForTask, gatherTaskPlanViaLlm, llmGenerateQuickTask, } from "../lib/task-add-llm.js";
-import { taskBuildPromptAbs, taskBuildPromptRel, } from "../lib/task-add-build-prompt.js";
-import { allocateNextTaskNumber, buildWorkNowTaskMarkdown, formatTaskId, titleFromIdea, uniqueTaskPath, } from "../lib/task-scaffold.js";
-import { readGitInfo } from "../lib/git.js";
-import { loadActionableTasks, pickInProgressTask, pickLatestDoneTask, } from "../lib/task.js";
-function relOrAbs(root, p) {
-    const r = relative(root, p);
-    return r === "" ? "." : r.startsWith("..") ? p : r;
-}
-async function maybeCloseInProgressTask(root, inProgress, nonInteractive) {
-    if (nonInteractive)
-        return true;
-    log.info(`Current TASK ${bold(inProgress.id)} is ${cyan("In Progress")}: ${dim(inProgress.title)}`);
-    log.blank();
-    const closeFirst = await yesNoSelect({
-        message: "Close this TASK first (commit, merge, clean tree) before starting a new one?",
-        defaultValue: true,
-    });
-    if (!closeFirst) {
-        log.warn(`Keeping ${inProgress.id} open — finish it or run ${cyan("vibeops done")} before switching branches.`);
-        return true;
-    }
-    log.blank();
-    log.step(`Closing ${inProgress.id} via vibeops done…`);
-    await doneCommand(inProgress.id, { cwd: root, allowDirty: true });
-    if (process.exitCode !== undefined && process.exitCode !== 0) {
-        log.error("Could not close the current TASK — fix blockers above, then run task add again.");
-        return false;
-    }
-    log.blank();
-    return true;
-}
-async function pickAddMode(nonInteractive) {
-    if (nonInteractive)
-        return "just";
-    const choice = await askSelect({
-        message: "How do you want to create the new TASK?",
-        nonInteractive: false,
-        choices: ["Just create task", "Create plan using LLM"],
-        default: "Just create task",
-    });
-    return choice.startsWith("Create plan") ? "plan" : "just";
-}
+import { fallbackTaskDraft, llmScaffoldTask } from "../lib/task-add-llm.js";
+import { allocateNextTaskNumber, formatTaskId, uniqueTaskPath, } from "../lib/task-scaffold.js";
+import { findBlockingTask, relPath } from "../lib/task-context.js";
+import { startTaskBranch } from "../lib/task-start.js";
+import { loadActionableTasks, readGitContext } from "../lib/task.js";
 export async function taskAddCommand(opts = {}) {
     const root = resolve(opts.cwd ?? process.cwd());
     const dryRun = opts.dryRun === true;
     const nonInteractive = opts.nonInteractive === true || dryRun || process.stdin.isTTY !== true;
     log.info(bold("vibeops task add"));
     log.blank();
-    let tasks = await loadActionableTasks(projectPaths(root).docsTasks);
-    const inProgress = pickInProgressTask(tasks);
-    if (inProgress !== null) {
-        const ok = await maybeCloseInProgressTask(root, inProgress, nonInteractive);
-        if (!ok)
-            return;
-        tasks = await loadActionableTasks(projectPaths(root).docsTasks);
+    const paths = projectPaths(root);
+    const blocking = await findBlockingTask(paths, root);
+    if (blocking !== null) {
+        const ctx = await readGitContext(blocking.filePath);
+        log.warn(`${yellow("Blocked")} — ${bold(blocking.id)} is still open (${blocking.title || "no title"}).`);
+        if (ctx) {
+            log.info(`  ${dim("branch")}  ${ctx.taskBranch}`);
+        }
+        log.info(`  ${dim("file")}   ${relPath(root, blocking.filePath)}`);
+        log.blank();
+        log.info(`Finish it first: ${cyan(`vibeops task done ${blocking.id}`)}`);
+        log.info(`Then run ${cyan("vibeops task add")} again.`);
+        process.exitCode = 1;
+        return;
     }
-    const mode = await pickAddMode(nonInteractive);
-    const latestDone = pickLatestDoneTask(tasks);
-    const nextNum = allocateNextTaskNumber(tasks);
-    const taskId = formatTaskId(nextNum);
-    const ideaDefault = opts.idea?.trim() ||
-        (latestDone ? `Follow-up after ${latestDone.id}` : "New work slice");
+    const ideaDefault = "New work slice";
     const idea = await askInput({
-        message: mode === "plan"
-            ? "What do you want to build? (starting point for planning)"
-            : "What are you doing now? (short)",
+        message: "What are you doing now? (short)",
         nonInteractive,
-        default: ideaDefault,
+        default: opts.idea?.trim() || ideaDefault,
         required: true,
     });
-    const paths = projectPaths(root);
-    const config = await readConfig(root);
-    const projectName = config?.name ?? "project";
-    let title = titleFromIdea(idea);
-    let slug = slugify(title);
-    let markdown = "";
-    let buildPromptMarkdown = null;
-    let llmNote = null;
-    if (mode === "plan") {
-        if (dryRun) {
-            log.info(`[dry-run] Would run LLM planning for ${bold(taskId)}`);
-            log.info(dim(`  idea: ${idea}`));
-            return;
-        }
-        if (nonInteractive) {
-            log.error("Create plan using LLM requires an interactive terminal (omit --non-interactive).");
-            process.exitCode = 1;
-            return;
-        }
-        log.step("LLM task planning (interactive questions)…");
-        const planned = await gatherTaskPlanViaLlm({
-            cwd: root,
-            taskId,
-            projectName,
-            seedIdea: idea,
-        });
-        if (planned === null) {
-            log.error("No LLM provider available for planning.");
-            process.exitCode = 1;
-            return;
-        }
-        markdown = planned.markdown;
-        buildPromptMarkdown = planned.buildPromptMarkdown;
-        llmNote = `planned via ${planned.provider}`;
-        const header = /^#\s+TASK-\d+:\s*(.+)$/m.exec(markdown);
-        if (header?.[1])
-            title = header[1].trim();
-        slug = slugify(title);
+    const tasks = await loadActionableTasks(paths.docsTasks);
+    const taskId = formatTaskId(allocateNextTaskNumber(tasks));
+    let title;
+    let slug;
+    let markdown;
+    if (dryRun || nonInteractive) {
+        const fb = fallbackTaskDraft(taskId, idea);
+        title = fb.title;
+        slug = fb.slug;
+        markdown = fb.markdown;
     }
     else {
-        let quick = null;
-        if (!nonInteractive || opts.idea) {
-            quick = await llmGenerateQuickTask({
-                cwd: root,
-                taskId,
-                idea,
-                latestDone,
-            });
-        }
-        if (quick !== null) {
-            title = quick.title;
-            slug = quick.slug;
-            markdown = quick.markdown;
-            llmNote = `quick scaffold via ${quick.provider}`;
+        const llm = await llmScaffoldTask({ cwd: root, taskId, idea });
+        if (llm !== null) {
+            title = llm.title;
+            slug = llm.slug;
+            markdown = llm.markdown;
+            log.skip(`Scaffold via ${llm.provider}`);
         }
         else {
-            const parent = inProgress ?? latestDone;
-            markdown = buildWorkNowTaskMarkdown({
-                id: taskId,
-                title,
-                idea,
-                mvpPhase: parent?.mvpPhase?.trim() || "Work-now slice",
-                spawnedFrom: parent?.id,
-            });
-            if (!nonInteractive) {
-                log.warn("LLM unavailable — using minimal TASK template.");
-            }
+            log.warn("LLM unavailable — using minimal TASK template.");
+            const fb = fallbackTaskDraft(taskId, idea);
+            title = fb.title;
+            slug = fb.slug;
+            markdown = fb.markdown;
         }
     }
-    const { filePath } = uniqueTaskPath(paths.docsTasks, taskId, slug, tasks.map((t) => t.filePath));
-    const relFile = relOrAbs(root, filePath);
-    const taskRelative = relFile.replace(/\\/g, "/");
-    const buildRel = taskBuildPromptRel(taskId);
-    const buildAbs = taskBuildPromptAbs(root, taskId);
-    if (buildPromptMarkdown === null) {
-        buildPromptMarkdown = defaultBuildPromptForTask(projectName, taskId, taskRelative);
-    }
+    const { filePath } = uniqueTaskPath(paths.docsTasks, taskId, slugify(slug || title), tasks.map((t) => t.filePath));
+    const relFile = relPath(root, filePath);
     if (dryRun) {
         log.info(`[dry-run] Would create ${bold(taskId)} → ${cyan(relFile)}`);
-        if (mode === "plan") {
-            log.info(`[dry-run] Would write ${cyan(buildRel)}`);
-        }
-        log.blank();
+        log.info(dim(`  branch task/${slugify(slug || title).replace(/^(\d+)-/, "$1-")}`));
         return;
     }
     if (await pathExists(filePath)) {
         throw new Error(`TASK file already exists: ${relFile}`);
     }
     await writeText(filePath, markdown);
-    await mkdir(join(root, ".vibeops", "generated"), { recursive: true });
-    await writeText(buildAbs, buildPromptMarkdown);
     log.ok(`Created ${bold(taskId)} → ${cyan(relFile)}`);
-    if (mode === "plan") {
-        log.ok(`Cursor build doc → ${cyan(buildRel)}`);
-    }
-    if (llmNote)
-        log.skip(llmNote);
-    const git = await readGitInfo(root);
-    if (!git.isRepo) {
-        log.warn("Not a git repository — TASK file saved. Run vibeops init --git, then start.");
-        return;
+    const config = await readConfig(root);
+    if (config === null) {
+        log.warn("No .vibeops.json — run vibeops init for full template.");
     }
     log.blank();
-    log.step(`Starting ${taskId} (branch + In Progress)…`);
-    await startCommand(taskId, { cwd: root, allowDirty: true });
-    if (process.exitCode !== undefined && process.exitCode !== 0) {
-        log.warn(`TASK file exists but start failed — run ${cyan(`vibeops start ${taskId}`)} when Git is ready.`);
+    log.step("Starting task branch…");
+    const started = await startTaskBranch({
+        cwd: root,
+        taskFile: filePath,
+        allowDirty: true,
+    });
+    if (!started) {
+        process.exitCode = 1;
         return;
     }
     log.blank();
-    if (mode === "plan") {
-        log.info(bold("Build in Cursor"));
-        log.info(`  Drag ${cyan(buildRel)} into a new chat and implement.`);
-    }
-    else {
-        log.info(bold("Work in Cursor"));
-        log.info(`  Edit ${cyan(relFile)} freely, then ${cyan(`vibeops done ${taskId}`)} when finished.`);
-    }
+    log.info(bold("Next in Cursor"));
+    log.info(`  Ask:  @${relFile} — plan Scope / Acceptance Criteria`);
+    log.info(`  Agent: same file — implement`);
+    log.info(`  Done: ${cyan(`vibeops task done ${taskId}`)}`);
 }