@goodtek/vibeops 0.4.0 → 1.0.0

package/dist/cli.js

@@ -1,265 +1,73 @@
 #!/usr/bin/env node
 import { Command } from "commander";
-import { agentListCommand } from "./commands/agent-list.js";
-import { agentPromptCommand } from "./commands/agent-prompt.js";
-import { agentShowCommand } from "./commands/agent-show.js";
-import { githubInitCommand } from "./commands/github-init.js";
-import { githubStatusCommand } from "./commands/github-status.js";
 import { initCommand } from "./commands/init.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 { statusCommand } from "./commands/status.js";
-import { taskCheckCommand } from "./commands/task-check.js";
+import { taskAddCommand } from "./commands/task-add.js";
 import { taskDoneCommand } from "./commands/task-done.js";
-import { taskGenerateCommand } from "./commands/task-generate.js";
-import { taskPullCommand } from "./commands/task-pull.js";
-import { taskRollbackCommand } from "./commands/task-rollback.js";
-import { taskStartCommand } from "./commands/task-start.js";
 import { VERSION } from "./version.js";
 const program = new Command();
 program
     .name("vibeops")
-    .description("VibeOps — a local CLI that keeps Cursor-based vibe coding on rails.\n" +
-    "  It installs docs, Cursor rules, AGENTS.md, agents, TASK templates,\n" +
-    "  and Git/Notion workflows into a project, then drives work one TASK at a time.")
+    .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 files into the current directory")
-    .option("--dry-run", "Show what would be created without writing any files")
-    .option("--force", "Overwrite existing files (use with care)")
-    .option("--cwd <path>", "Run against a different directory")
-    .option("--name <projectName>", "Project name written into .vibeops.json")
-    .option("--git", "Initialize a Git repository without prompting")
-    .option("--no-git", "Skip Git initialization and commits")
-    .option("--initial-commit", "Run `git add .` and create an initial commit")
-    .option("--no-initial-commit", "Do not create an initial commit")
-    .option("--default-branch <name>", "Default Git branch name (default `main`)")
-    .option("--commit-message <message>", "Initial commit message (default 'chore: initialize vibeops project')")
-    .action(async (options) => {
-    await initCommand(options);
-});
-program
-    .command("status")
-    .description("Show VibeOps installation, TASK counts, and integration state")
-    .option("--json", "Print machine-readable JSON")
-    .option("--cwd <path>", "Inspect a different directory")
-    .action(async (options) => {
-    await statusCommand(options);
-});
-program
-    .command("plan")
-    .description("Requires `vibeops init`: LLM planning → ProjectBrief + planning prompt; optional --apply-planner runs the planner via the same LLM (docs + TASKs, commit, push, Notion). Use --legacy-wizard for the fixed 20-question flow")
-    .option("--idea <text>", "One-line idea default (use `Name: idea` to extract the project name)")
-    .option("--from <path>", "Read an existing brief markdown and regenerate the prompt")
-    .option("--output <path>", "Output path for the Cursor planning prompt (default `.vibeops/generated/plan-prompt.md`)")
-    .option("--non-interactive", "Skip prompts and use the supplied values plus safe placeholders (no LLM)")
-    .option("--legacy-wizard", "Use the original 20-question wizard instead of an LLM planning session")
-    .option("--provider <id>", "LLM provider when several are available: openai | codex-oauth | cursor-agent")
-    .option("--model <id>", "LLM model id for the selected provider (skips interactive model list; same as setting VIBEOPS_*_MODEL for that path)")
-    .option("--cwd <path>", "Run against a different directory")
-    .option("--apply-planner", "After writing the brief + prompt: call the same LLM provider to emit docs/project + docs/tasks; then (TTY) ask commit → push → Notion in order, or (--non-interactive) commit unless --no-git-commit, push only with --push, Notion unless --no-notion-sync")
-    .option("--apply-dry-run", "With --apply-planner (or alone): call the LLM and list files that would be written; no writes, git, or Notion")
-    .option("--no-git-commit", "With --apply-planner: skip git commit after writes")
-    .option("--push", "With --apply-planner: run git push after commit (TTY: optional `vibeops github init` before push; skips the push Yes/No prompt)")
-    .option("--no-notion-sync", "With --apply-planner: skip Notion sync even when the brief enables it")
-    .action(async (options) => {
-    const provider = options.provider === "openai" ||
-        options.provider === "codex-oauth" ||
-        options.provider === "cursor-agent"
-        ? options.provider
-        : undefined;
-    await planCommand({
-        idea: options.idea,
-        from: options.from,
-        output: options.output,
-        nonInteractive: options.nonInteractive,
-        legacyWizard: options.legacyWizard === true,
-        provider,
-        llmModel: typeof options.model === "string" ? options.model : undefined,
-        cwd: options.cwd,
-        applyPlanner: options.applyPlanner === true,
-        applyPlannerDryRun: options.applyDryRun === true,
-        noGitCommit: options.noGitCommit === true,
-        gitPush: options.push === true,
-        noNotionSync: options.noNotionSync === true,
-    });
-});
-const agent = program
-    .command("agent")
-    .description("Inspect the `.vibeops/agents/*` agent definitions");
-agent
-    .command("list")
-    .description("List available agents")
-    .option("--json", "Print machine-readable JSON")
-    .option("--cwd <path>", "Inspect a different directory")
-    .action(async (options) => {
-    await agentListCommand(options);
-});
-agent
-    .command("show <name>")
-    .description("Print an agent definition body")
-    .option("--raw", "Include frontmatter in the output")
-    .option("--cwd <path>", "Inspect a different directory")
-    .action(async (name, options) => {
-    await agentShowCommand(name, options);
-});
-agent
-    .command("prompt <name> <taskId>")
-    .description("Print a Cursor-ready prompt built from the agent + TASK context")
-    .option("--context <path...>", "Additional context file paths")
-    .option("--cwd <path>", "Inspect a different directory")
-    .action(async (name, taskId, options) => {
-    await agentPromptCommand(name, taskId, options);
-});
-const task = program
-    .command("task")
-    .description("TASK lifecycle commands");
-task
-    .command("generate")
-    .description("Build a Cursor prompt for generating TASK files, or with --scaffold write skeleton TASK markdown")
-    .option("--from <path>", "Primary backlog/brief markdown to feed into the prompt")
-    .option("--output <path>", "Output path for the generated prompt (default `.vibeops/generated/task-generate-prompt.md`)")
-    .option("--count <number>", "Suggested TASK count for Cursor (default 8, warns above 20)")
-    .option("--phase <name>", "Generate TASKs for a specific phase label only (e.g. 'MVP 4')")
-    .option("--scaffold", "Write skeleton TASK markdown files directly, without an LLM")
-    .option("--dry-run", "Print the plan without writing or modifying files")
-    .option("--cwd <path>", "Run against a different directory")
-    .action(async (options) => {
-    await taskGenerateCommand(options);
-});
-task
-    .command("start <taskId>")
-    .description("Confirm a clean working tree (or docs-only governance changes), create the task branch, record Status/Git context, and print a Builder prompt")
-    .option("--dry-run", "Print the plan without touching files or Git")
-    .option("--allow-dirty", "Proceed even if the Git working tree is dirty (including non-doc changes)")
-    .option("--agent <name>", "Agent to build the prompt with (default `builder`)")
-    .option("--cwd <path>", "Run against a different directory")
-    .action(async (taskId, options) => {
-    await taskStartCommand(taskId, options);
-});
+    .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")
+    .option("--no-git", "Skip Git")
+    .option("--initial-commit", "Create initial commit")
+    .option("--no-initial-commit", "Skip initial commit")
+    .option("--default-branch <name>", "Default branch (default main)")
+    .option("--commit-message <message>", "Initial commit message")
+    .action(async (opts) => {
+    await initCommand(opts);
+});
+const task = program.command("task").description("TASK lifecycle");
 task
-    .command("prompt <taskId>")
-    .description("Print a Cursor-ready prompt built from the TASK + agent context")
-    .option("--agent <name>", "Agent name (orchestrator / planner / architect / builder / reviewer / tester / docs / recovery)")
-    .option("--context <path...>", "Additional context file paths")
-    .option("--cwd <path>", "Inspect a different directory")
-    .action(async (taskId, options) => {
-    await agentPromptCommand(options.agent ?? "builder", taskId, {
-        cwd: options.cwd,
-        context: options.context,
+    .command("add")
+    .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({
+        dryRun: Boolean(opts.dryRun),
+        nonInteractive: Boolean(opts.nonInteractive),
+        idea: opts.idea,
+        cwd: opts.cwd,
     });
 });
 task
-    .command("check <taskId>")
-    .description("Read-only check: git diff/log + acceptance criteria + doc updates + Result fields + a Reviewer prompt")
-    .option("--strict", "Exit with code 1 if any required item is missing")
-    .option("--agent <name>", "Agent to build the prompt with (default `reviewer`)")
-    .option("--cwd <path>", "Inspect a different directory")
-    .action(async (taskId, options) => {
-    await taskCheckCommand(taskId, options);
-});
-task
-    .command("done <taskId>")
-    .description("Validate Result/Test Result, move Status to Review, and print a commit message (no auto-commit)")
-    .option("--dry-run", "Print the plan without touching files")
-    .option("--finalize", "Move Status to Done instead of Review (use after human review)")
-    .option("--cwd <path>", "Run against a different directory")
-    .action(async (taskId, options) => {
-    await taskDoneCommand(taskId, options);
-});
-task
-    .command("rollback <taskId>")
-    .description("Default: advisory only. --confirm: non-destructive rollback. --confirm-destructive: hard reset.")
-    .option("--confirm", "Allow non-destructive rollback execution (branch-delete etc.)")
-    .option("--confirm-destructive", "Allow destructive rollback execution (reset --hard etc.)")
-    .option("--strategy <name>", "branch-delete | reset-base | revert-merge (default branch-delete)")
-    .option("--keep-branch", "Keep the task branch even when using branch-delete")
-    .option("--dry-run", "Print the plan without running any git commands, even with --confirm")
-    .option("--cwd <path>", "Run against a different directory")
-    .action(async (taskId, options) => {
-    await taskRollbackCommand(taskId, options);
-});
-task
-    .command("pull")
-    .description("Generate `docs/tasks/*.md` skeletons from Notion Tasks DB rows (defaults to Status = Planned)")
-    .option("--dry-run", "Print the plan without touching files or Notion")
-    .option("--json", "Print machine-readable JSON")
-    .option("--status <name>", "Notion Status values to pull (comma-separated, e.g. 'Planned,Ready'). Default `Planned`")
-    .option("--limit <number>", "Maximum rows to pull from Notion (default 20, max 100)")
-    .option("--cwd <path>", "Run against a different directory")
-    .option("--verbose", "Print a decision trace per considered row (taskId / pageId / docsPath / reason)")
-    .action(async (options) => {
-    await taskPullCommand(options);
-});
-const notion = program
-    .command("notion")
-    .description("Notion dashboard sync");
-notion
-    .command("init")
-    .description("Interactive setup: use arrow keys + Enter to pick Yes/No, then write `.vibeops.json` `notion` section and `.vibeops.env(.example)`")
-    .option("--dry-run", "Print the plan without changing files (no interactive prompts)")
-    .option("--enable", "Set `notion.enabled = true` and skip the first prompt")
-    .option("--projects-db <id>", "Set `notion.projectsDatabaseId` (skip the prompt)")
-    .option("--tasks-db <id>", "Set `notion.tasksDatabaseId` (skip the prompt)")
-    .option("--non-interactive", "Force non-interactive mode in a TTY (use flag values + safe defaults only)")
-    .option("--cwd <path>", "Run against a different directory")
-    .action(async (options) => {
-    await notionInitCommand(options);
-});
-notion
-    .command("test")
-    .description("Read-only check: Notion API auth + access to Projects/Tasks DBs + required-property schema validation")
-    .option("--json", "Print machine-readable JSON")
-    .option("--debug-shape", "Also print a token-safe diagnostic of the Projects/Tasks retrieve responses (top-level keys, data_sources, etc.)")
-    .option("--cwd <path>", "Run against a different directory")
-    .action(async (options) => {
-    await notionTestCommand(options);
-});
-notion
-    .command("sync")
-    .description("Push `docs/project` + `docs/tasks` metadata into Notion Projects/Tasks DBs (read-only on local files)")
-    .option("--dry-run", "Print the plan without any Notion mutation (queries only)")
-    .option("--json", "Print machine-readable JSON")
-    .option("--only-tasks", "Sync the Tasks DB only (leave the Project row alone)")
-    .option("--only-project", "Sync the Project DB only (leave Task rows alone)")
-    .option("--cwd <path>", "Run against a different directory")
-    .action(async (options) => {
-    await notionSyncCommand(options);
+    .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 (taskRef, opts) => {
+    await taskDoneCommand(taskRef, {
+        dryRun: Boolean(opts.dryRun),
+        noMerge: Boolean(opts.noMerge),
+        allowDirty: Boolean(opts.allowDirty),
+        yes: Boolean(opts.yes),
+        cwd: opts.cwd,
+    });
 });
-const github = program
-    .command("github")
-    .description("GitHub repository integration");
-github
+program
     .command("status")
-    .description("Read-only check: gh install/auth + git remotes + `.vibeops.json` github section + `package.json` repo fields")
-    .option("--json", "Print machine-readable JSON")
-    .option("--cwd <path>", "Inspect a different directory")
-    .action(async (options) => {
-    await githubStatusCommand(options);
-});
-github
-    .command("init")
-    .description("Interactive setup: check gh auth, manage the git remote, optionally `gh repo create`, then update `.vibeops.json` and `package.json`")
-    .option("--dry-run", "Print the plan without running gh / git or writing files")
-    .option("--yes", "Skip interactive prompts and use safe defaults")
-    .option("--owner <owner>", "GitHub owner (user or org)")
-    .option("--repo <repo>", "GitHub repo name")
-    .option("--public", "Force visibility = public (skip the prompt)")
-    .option("--private", "Force visibility = private (skip the prompt)")
-    .option("--remote <name>", "Git remote name (default `origin`)")
-    .option("--connect <ownerOrUrl>", "Connect to an existing repo instead of creating one (owner/repo or https/ssh URL)")
-    .option("--no-package-update", "Do not modify `package.json` repository/homepage/bugs fields")
-    .option("--cwd <path>", "Run against a different directory")
-    .action(async (options) => {
-    await githubInitCommand({
-        ...options,
-        // Commander turns `--no-package-update` into `packageUpdate: false`.
-        // Our command type still accepts the legacy `noPackageUpdate`
-        // shape for tests / direct invocation.
-        noPackageUpdate: options.packageUpdate === false,
+    .description("Briefing: active TASK, Git, next hint")
+    .option("--json", "JSON output")
+    .option("--cwd <path>", "Target directory")
+    .action(async (opts) => {
+    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

@@ -0,0 +1,100 @@
+import { resolve } from "node:path";
+import { pathExists, writeText } from "../lib/filesystem.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 { 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();
+    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 ideaDefault = "New work slice";
+    const idea = await askInput({
+        message: "What are you doing now? (short)",
+        nonInteractive,
+        default: opts.idea?.trim() || ideaDefault,
+        required: true,
+    });
+    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 {
+        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 {
+            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, 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)}`);
+        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);
+    log.ok(`Created ${bold(taskId)} → ${cyan(relFile)}`);
+    const config = await readConfig(root);
+    if (config === null) {
+        log.warn("No .vibeops.json — run vibeops init for full template.");
+    }
+    log.blank();
+    log.step("Starting task branch…");
+    const started = await startTaskBranch({
+        cwd: root,
+        taskFile: filePath,
+        allowDirty: true,
+    });
+    if (!started) {
+        process.exitCode = 1;
+        return;
+    }
+    log.blank();
+    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}`)}`);
+}