@goodtek/vibeops 0.2.0

package/dist/lib/package-json.js

@@ -0,0 +1,133 @@
+import { join } from "node:path";
+import { readTextOrNull, writeText } from "./filesystem.js";
+const PACKAGE_JSON_FILE = "package.json";
+export async function readPackageJson(cwd) {
+    const abs = join(cwd, PACKAGE_JSON_FILE);
+    const raw = await readTextOrNull(abs);
+    if (raw === null)
+        return null;
+    try {
+        const data = JSON.parse(raw);
+        return { path: abs, raw, data };
+    }
+    catch {
+        return null;
+    }
+}
+/** Read the canonical repository URL string, regardless of shape. */
+export function readRepositoryUrl(pkg) {
+    const r = pkg.repository;
+    if (typeof r === "string")
+        return r;
+    if (r !== null && typeof r === "object" && typeof r.url === "string")
+        return r.url;
+    return "";
+}
+export function readBugsUrl(pkg) {
+    const b = pkg.bugs;
+    if (typeof b === "string")
+        return b;
+    if (b !== null && typeof b === "object" && typeof b.url === "string")
+        return b.url;
+    return "";
+}
+export function readHomepage(pkg) {
+    return typeof pkg.homepage === "string" ? pkg.homepage : "";
+}
+function detectIndent(raw) {
+    // Look at the first indented line.
+    for (const line of raw.split(/\r?\n/)) {
+        const m = /^(\s+)\S/.exec(line);
+        if (m === null)
+            continue;
+        const indent = m[1];
+        if (indent.startsWith("\t"))
+            return 0;
+        if (indent.length > 0)
+            return indent.length;
+    }
+    return 2;
+}
+function stringifyKeepingTrailingNewline(data, raw, indent) {
+    const trailing = raw.endsWith("\n") ? "\n" : "";
+    return `${JSON.stringify(data, null, indent || 2)}${trailing}`;
+}
+export function buildRepositoryFieldsPatch({ owner, repo, }) {
+    return {
+        repositoryUrl: `git+https://github.com/${owner}/${repo}.git`,
+        homepage: `https://github.com/${owner}/${repo}#readme`,
+        bugsUrl: `https://github.com/${owner}/${repo}/issues`,
+    };
+}
+export async function updatePackageRepositoryFields(input) {
+    const read = await readPackageJson(input.cwd);
+    const path = join(input.cwd, PACKAGE_JSON_FILE);
+    if (read === null) {
+        return {
+            ok: false,
+            reason: "missing",
+            diffs: [],
+            written: false,
+            path,
+        };
+    }
+    const patch = buildRepositoryFieldsPatch(input.patch);
+    const before = {
+        repositoryUrl: readRepositoryUrl(read.data),
+        homepage: readHomepage(read.data),
+        bugsUrl: readBugsUrl(read.data),
+    };
+    const next = { ...read.data };
+    // repository: always normalize to object shape with type=git.
+    const prevRepo = read.data.repository;
+    const repoObject = prevRepo !== null && typeof prevRepo === "object" ? { ...prevRepo } : {};
+    repoObject.type = repoObject.type ?? "git";
+    repoObject.url = patch.repositoryUrl;
+    next.repository = repoObject;
+    next.homepage = patch.homepage;
+    const prevBugs = read.data.bugs;
+    const bugsObject = prevBugs !== null && typeof prevBugs === "object" ? { ...prevBugs } : {};
+    bugsObject.url = patch.bugsUrl;
+    next.bugs = bugsObject;
+    const diffs = [];
+    if (before.repositoryUrl !== patch.repositoryUrl) {
+        diffs.push({
+            field: "repository.url",
+            before: before.repositoryUrl,
+            after: patch.repositoryUrl,
+        });
+    }
+    if (before.homepage !== patch.homepage) {
+        diffs.push({
+            field: "homepage",
+            before: before.homepage,
+            after: patch.homepage,
+        });
+    }
+    if (before.bugsUrl !== patch.bugsUrl) {
+        diffs.push({
+            field: "bugs.url",
+            before: before.bugsUrl,
+            after: patch.bugsUrl,
+        });
+    }
+    if (input.dryRun === true || diffs.length === 0) {
+        return {
+            ok: true,
+            diffs,
+            next,
+            written: false,
+            path,
+        };
+    }
+    const indent = detectIndent(read.raw);
+    const text = stringifyKeepingTrailingNewline(next, read.raw, indent);
+    await writeText(path, text);
+    return {
+        ok: true,
+        diffs,
+        next,
+        written: true,
+        path,
+    };
+}

package/dist/lib/paths.js

@@ -0,0 +1,26 @@
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+const here = dirname(fileURLToPath(import.meta.url));
+export const PACKAGE_ROOT = resolve(here, "..", "..");
+export const TEMPLATES_ROOT = join(PACKAGE_ROOT, "templates");
+export const VIBEOPS_CONFIG_FILE = ".vibeops.json";
+export const VIBEOPS_ENV_FILE = ".vibeops.env";
+export const VIBEOPS_ENV_EXAMPLE_FILE = ".vibeops.env.example";
+export function projectPaths(root) {
+    const abs = resolve(root);
+    return {
+        root: abs,
+        config: join(abs, VIBEOPS_CONFIG_FILE),
+        envExample: join(abs, VIBEOPS_ENV_EXAMPLE_FILE),
+        agentsMd: join(abs, "AGENTS.md"),
+        cursorRules: join(abs, ".cursor", "rules"),
+        docsProject: join(abs, "docs", "project"),
+        docsTasks: join(abs, "docs", "tasks"),
+        docsLogs: join(abs, "docs", "logs"),
+        vibeopsDir: join(abs, ".vibeops"),
+        vibeopsAgents: join(abs, ".vibeops", "agents"),
+        vibeopsPrompts: join(abs, ".vibeops", "prompts"),
+        vibeopsWorkflows: join(abs, ".vibeops", "workflows"),
+        gitignore: join(abs, ".gitignore"),
+    };
+}

package/dist/lib/project-docs.js

@@ -0,0 +1,95 @@
+import { join, relative } from "node:path";
+import { readTextOrNull } from "./filesystem.js";
+import { projectPaths } from "./paths.js";
+/**
+ * Canonical project documentation slots that `task generate` looks at.
+ * Files that don't exist are returned with `content: null` so the caller
+ * can decide whether to mention them as "missing" in the generated prompt.
+ */
+const PROJECT_SLOTS = [
+    { label: "Backlog (primary)", fileName: "07-backlog.md", category: "backlog", primary: true },
+    { label: "Overview", fileName: "00-overview.md", category: "overview" },
+    { label: "Requirements", fileName: "01-requirements.md", category: "requirements" },
+    { label: "MVP Scope", fileName: "02-mvp-scope.md", category: "mvp-scope" },
+    { label: "Architecture", fileName: "03-architecture.md", category: "architecture" },
+    { label: "Tech Stack", fileName: "04-tech-stack.md", category: "tech-stack" },
+    { label: "Current State", fileName: "05-current-state.md", category: "current-state" },
+    { label: "Decisions", fileName: "06-decisions.md", category: "decisions" },
+    { label: "Env", fileName: "08-env.md", category: "env" },
+    { label: "Deployment", fileName: "09-deployment.md", category: "deployment" },
+];
+/**
+ * Fallback set of project doc filenames for repositories that pre-date the
+ * 10-file template layout (e.g. this VibeOps repo itself uses 00–05).
+ * Only consulted when a slot above is missing.
+ */
+const LEGACY_FALLBACKS = new Map([
+    ["07-backlog.md", ["05-backlog.md"]],
+    ["00-overview.md", []],
+    ["03-architecture.md", ["01-architecture.md"]],
+    ["04-tech-stack.md", ["02-tech-stack.md"]],
+    ["05-current-state.md", ["03-current-state.md"]],
+    ["06-decisions.md", ["04-decisions.md"]],
+]);
+function relDisplay(root, abs) {
+    const r = relative(root, abs);
+    return r.length === 0 ? "." : r;
+}
+async function readSlotWithFallback(cwd, spec) {
+    const paths = projectPaths(cwd);
+    const canonical = join(paths.docsProject, spec.fileName);
+    let abs = canonical;
+    let content = await readTextOrNull(abs);
+    if (content === null) {
+        for (const fallback of LEGACY_FALLBACKS.get(spec.fileName) ?? []) {
+            abs = join(paths.docsProject, fallback);
+            content = await readTextOrNull(abs);
+            if (content !== null)
+                break;
+        }
+        if (content === null)
+            abs = canonical;
+    }
+    return {
+        label: spec.label,
+        path: abs,
+        relativePath: relDisplay(cwd, abs),
+        content,
+        primary: spec.primary === true,
+        category: spec.category,
+    };
+}
+export async function collectInputDocs(inputs) {
+    const slots = [];
+    for (const spec of PROJECT_SLOTS) {
+        slots.push(await readSlotWithFallback(inputs.cwd, spec));
+    }
+    const briefContent = await readTextOrNull(inputs.briefAbs);
+    const brief = {
+        label: "Project Brief",
+        path: inputs.briefAbs,
+        relativePath: relDisplay(inputs.cwd, inputs.briefAbs),
+        content: briefContent,
+        primary: false,
+        category: "brief",
+    };
+    let from = null;
+    if (typeof inputs.fromAbs === "string" && inputs.fromAbs.length > 0) {
+        const content = await readTextOrNull(inputs.fromAbs);
+        from = {
+            label: "Custom input (--from)",
+            path: inputs.fromAbs,
+            relativePath: relDisplay(inputs.cwd, inputs.fromAbs),
+            content,
+            primary: true,
+            category: "custom",
+        };
+    }
+    return { slots, brief, from };
+}
+export function presentSlots(docs) {
+    return docs.slots.filter((s) => s.content !== null);
+}
+export function missingSlots(docs) {
+    return docs.slots.filter((s) => s.content === null);
+}

package/dist/lib/prompt-builder.js

@@ -0,0 +1,125 @@
+function renderTopList(values) {
+    if (values.length === 0)
+        return "- _(none selected)_";
+    return values.map((v) => `- ${v}`).join("\n");
+}
+function renderInlineList(label, values) {
+    if (values.length === 0)
+        return `- **${label}**: _(none selected)_`;
+    const head = `- **${label}**:`;
+    const items = values.map((v) => `  - ${v}`).join("\n");
+    return `${head}\n${items}`;
+}
+function renderBool(value) {
+    return value ? "yes" : "no";
+}
+function summary(brief) {
+    const lines = [];
+    lines.push(`- **Project name**: ${brief.projectName}`);
+    lines.push(`- **One-line idea**: ${brief.oneLineIdea}`);
+    lines.push(`- **Project type**: ${brief.projectType}`);
+    lines.push(renderInlineList("Target users", brief.targetUsers));
+    lines.push(`- **Core problem**: ${brief.coreProblem}`);
+    lines.push(renderInlineList("MVP must-have features", brief.mvpFeatures));
+    lines.push(renderInlineList("Out of scope for MVP", brief.outOfScope));
+    lines.push(`- **Frontend**: ${brief.frontend}`);
+    lines.push(`- **Backend**: ${brief.backend}`);
+    lines.push(`- **Database**: ${brief.database}`);
+    lines.push(`- **ORM / DB layer**: ${brief.dbLayer}`);
+    lines.push(`- **Package manager**: ${brief.packageManager}`);
+    lines.push(renderInlineList("Deployment target", brief.deploymentTargets));
+    lines.push(renderInlineList("Auth requirement", brief.authRequirements));
+    lines.push(renderInlineList("External integrations", brief.integrations));
+    lines.push(`- **Use Notion dashboard sync**: ${renderBool(brief.useNotion)}`);
+    lines.push(`- **Use Git task branch workflow**: ${renderBool(brief.useGitWorkflow)}`);
+    lines.push(`- **Agent workflow level**: ${brief.agentWorkflowLevel}`);
+    lines.push(renderInlineList("Risk areas", brief.risks));
+    lines.push(`- **Success criteria**: ${brief.successCriteria}`);
+    return lines.join("\n");
+}
+export function buildPlanPrompt(inputs) {
+    const { brief, meta, briefRelativePath } = inputs;
+    const assumptions = meta.assumptions.length > 0
+        ? meta.assumptions.map((a) => `- ${a}`).join("\n")
+        : "- _(none recorded)_";
+    return `# VibeOps Plan Prompt — Cursor Planner Agent
+
+> This file was produced by \`vibeops plan\`. Open a new chat in **Cursor** and paste the full contents of this file. VibeOps does not call LLMs directly — the Planner Agent receives this input and fills in \`docs/project/*\` plus the initial backlog.
+
+- Brief location: \`${briefRelativePath}\`
+- VibeOps version: ${meta.vibeopsVersion}
+- Generated: ${meta.generatedAt}
+- Source: ${meta.source} · schemaVersion: ${meta.schemaVersion}
+
+---
+
+## Role: Planner Agent
+
+Follow the definition in \`.vibeops/agents/planner.md\`. You do not write application code. You produce:
+
+1. Updates to \`docs/project/*\` — vision / requirements / scope / architecture draft / tech stack / decisions / backlog / environment / deployment notes.
+2. An initial backlog of \`docs/tasks/TASK-NNN-*.md\` files (3-6 to start). Each TASK contains the sections Status · MVP Phase · Goal · Scope · Out of Scope · Acceptance Criteria · Test Plan · Result · Test Result.
+
+## Hard rules (failure if violated)
+
+- Do not produce application code. The deliverable for this round is limited to \`docs/**\`.
+- Do not touch VibeOps' own config (\`.vibeops/\`, \`.vibeops.json\`, \`templates/\`).
+- Source-of-truth rules: \`docs/tasks/*.md\` = AI execution baseline, \`docs/project/*.md\` = design / current-state baseline, Git commits/branches = change history, Notion = human dashboard (summary / status / priority / docs path only), chat is never a baseline.
+- One TASK, one focus. Surface inter-TASK dependencies in the body.
+- Never hide assumptions. Record them in both the docs/project bodies and the closing "Assumptions" section.
+- Notion / Git workflow / agent workflow level follow the ProjectBrief values below as-is. Do not change them on a whim.
+
+## ProjectBrief (user answers)
+
+${summary(brief)}
+
+### Assumptions inherited from the brief
+
+${assumptions}
+
+## Output format
+
+Produce the response in this exact order:
+
+1. **Plan Summary** — 5 to 8 bullets capturing the direction derived from the ProjectBrief (audience, scope, tech selections, key risks).
+2. **docs/project/\\*** — emit the 8 files below, each in its own fenced code block. The first line of each block is \`<!-- file: docs/project/XX-name.md -->\`. (\`03-architecture\` and \`05-current-state\` are not produced in this round.)
+   - \`docs/project/00-overview.md\`
+   - \`docs/project/01-requirements.md\`
+   - \`docs/project/02-mvp-scope.md\`
+   - \`docs/project/04-tech-stack.md\`
+   - \`docs/project/06-decisions.md\`
+   - \`docs/project/07-backlog.md\`
+   - \`docs/project/08-env.md\`
+   - \`docs/project/09-deployment.md\`
+3. **docs/tasks/TASK-NNN-\\*** — 3 to 6 initial backlog items. Each in a fenced block beginning with \`<!-- file: docs/tasks/TASK-NNN-slug.md -->\`.
+4. **Changed file list** — the full list of files produced above.
+5. **Assumptions** — decisions the user must reconfirm (\`(none)\` if there are none).
+
+## Field mapping (brief field → docs file)
+
+- \`00-overview.md\` ← projectName, oneLineIdea, projectType, targetUsers, coreProblem, successCriteria
+- \`01-requirements.md\` ← mvpFeatures, authRequirements, integrations, targetUsers
+- \`02-mvp-scope.md\` ← mvpFeatures (IN), outOfScope (OUT), successCriteria
+- \`04-tech-stack.md\` ← frontend, backend, database, dbLayer, packageManager
+- \`06-decisions.md\` ← useNotion, useGitWorkflow, agentWorkflowLevel, packageManager, plus any auto-derived decisions.
+- \`07-backlog.md\` ← decompose mvpFeatures into TASKs (1-2 per feature + 1 setup). Include priority and definition of done.
+- \`08-env.md\` ← env variables per integration (e.g. OpenAI → OPENAI_API_KEY) and their purpose.
+- \`09-deployment.md\` ← deployment notes per deploymentTargets. If only "Not sure" is selected, state that explicitly and mark the decision as pending.
+
+## Notion / Git / Agent workflow handling
+
+- Use Notion dashboard sync: ${renderBool(brief.useNotion)} → record in \`06-decisions.md\`. ${brief.useNotion ? "Decision: VibeOps will sync Notion DB metadata." : "Decision: no Notion sync (revisit in a future TASK if needed)."}
+- Use Git task branch workflow: ${renderBool(brief.useGitWorkflow)} → ${brief.useGitWorkflow ? "TASK lifecycle assumes the task/TASK-NNN-slug branch model." : "Record that the Git task-branch model is not used (linear workflow)."}
+- Agent workflow level: \`${brief.agentWorkflowLevel}\` → fix the agent line-up in \`06-decisions.md\`.
+
+## Risk areas → docs
+
+${renderTopList(brief.risks)}
+
+Record each risk in \`07-backlog.md\` or in the Risks section of the corresponding TASK. Operational risks such as "Authentication/security" or "Browser automation reliability" become candidates for their own TASK.
+
+---
+
+Apply the rules above and produce the response. After you respond, a human reviews via \`git diff\` and commits.
+`;
+}

package/dist/lib/task-generator.js

@@ -0,0 +1,183 @@
+export const TASK_GENERATE_SCHEMA_VERSION = 1;
+export const REQUIRED_TASK_SECTIONS = [
+    "Status",
+    "MVP Phase",
+    "Goal",
+    "Background",
+    "Scope",
+    "Out of Scope",
+    "Acceptance Criteria",
+    "Files to Inspect First",
+    "Expected Files to Change",
+    "Risks",
+    "Test Plan",
+    "Rollback Plan",
+    "Git Context",
+    "Notion Page",
+    "Implementation Plan",
+    "Result",
+    "Test Result",
+    "Review Notes",
+];
+/**
+ * Convert an arbitrary string to a TASK-filename slug.
+ * - lowercase
+ * - ASCII-only (non-ASCII letters dropped)
+ * - non-alphanum collapsed to `-`
+ * - leading/trailing `-` removed, repeated `-` compressed
+ * - empty result → `task`
+ */
+export function slugify(input, fallback = "task") {
+    const cleaned = input
+        .toLowerCase()
+        .normalize("NFKD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .replace(/-+/g, "-");
+    return cleaned.length > 0 ? cleaned : fallback;
+}
+function header(inputs) {
+    const lines = [];
+    lines.push("# VibeOps Task-Generation Prompt — Cursor Planner Agent");
+    lines.push("");
+    lines.push("> This file was produced by `vibeops task generate`. Open a new chat in **Cursor** and paste the full contents of this file. VibeOps does not call LLM, Cursor CLI, Notion, or GitHub APIs directly — the **Planner Agent** receiving this prompt creates the `docs/tasks/TASK-*.md` files.");
+    lines.push("");
+    lines.push(`- VibeOps version: ${inputs.vibeopsVersion}`);
+    lines.push(`- Generated: ${inputs.generatedAt}`);
+    lines.push(`- Generated by: \`vibeops task generate\``);
+    lines.push(`- Prompt location: \`${inputs.outputRelative}\``);
+    lines.push(`- Schema version: ${TASK_GENERATE_SCHEMA_VERSION}`);
+    lines.push("");
+    return lines.join("\n");
+}
+function role() {
+    return `## Role: Planner Agent
+
+Follow the definition in \`.vibeops/agents/planner.md\` if it is installed. You **do not write application code**. You produce \`docs/tasks/TASK-NNN-slug.md\` files. Each TASK must be small enough for a single Builder Agent to finish in one Cursor session.`;
+}
+function hardRules() {
+    return `## Hard rules (failure if violated)
+
+- Never produce application code (\`src/**\`, \`lib/**\`, \`app/**\`, tests, build scripts, etc.). The deliverable for this round is \`docs/tasks/TASK-NNN-slug.md\` files only.
+- Do not touch VibeOps' own config (\`.vibeops/\`, \`.vibeops.json\`, \`templates/\`).
+- Never call LLM APIs, Cursor CLI, Notion APIs, or GitHub APIs directly. You only produce markdown.
+- Source-of-truth rules:
+  - **\`docs/tasks/*.md\` = AI execution source of truth** (Builder/Reviewer/Tester agents only read these files).
+  - **\`docs/project/*.md\` = design + current-state baseline** (the input the Planner reads for this round).
+  - **Git commits/branches = change history**.
+  - **Notion = human dashboard** (exposes summary / status / priority / docs path only — never execution details).
+  - Do not trust chat memory.
+- One TASK, one focus. Surface inter-TASK dependencies in the body (e.g. "TASK-014 depends on TASK-013").
+- Never hide assumptions. Record them in the closing "Assumptions" section of the response.`;
+}
+function inventoryRow(slot) {
+    const flag = slot.content === null ? "·" : "✓";
+    const note = slot.content === null ? " _(missing)_" : "";
+    const primaryTag = slot.primary ? " **(primary)**" : "";
+    return `- [${flag}] \`${slot.relativePath}\` — ${slot.label}${primaryTag}${note}`;
+}
+function inventory(docs) {
+    const lines = ["## Input documents (for this round)"];
+    lines.push("");
+    if (docs.from)
+        lines.push(inventoryRow(docs.from));
+    for (const slot of docs.slots)
+        lines.push(inventoryRow(slot));
+    lines.push(inventoryRow(docs.brief));
+    lines.push("");
+    lines.push("> `[✓]` = file read from disk. `[·]` = missing or empty slot — its content is not inlined below. Do not over-guess for missing slots; record them in \"Assumptions\".");
+    return lines.join("\n");
+}
+function objective(inputs) {
+    const lines = ["## Objective"];
+    lines.push("");
+    lines.push(`Read the inputs above and produce roughly **${inputs.count} new TASK files**. The first TASK number is \`${inputs.nextTaskId}\` (the next number after the highest existing \`docs/tasks/TASK-*.md\`). Skip any number that already exists on disk.`);
+    if (typeof inputs.phase === "string" && inputs.phase.length > 0) {
+        lines.push("");
+        lines.push(`- **Phase filter**: this round only produces TASKs whose phase is \`${inputs.phase}\`. Even if you see work for other phases, leave it for a separate round.`);
+    }
+    if (inputs.countWarning) {
+        lines.push("");
+        lines.push(`- ⚠️ A recommended count of ${inputs.count} is on the high side. Make sure each TASK really does fit a single Cursor session, and lower the count if anything is vague.`);
+    }
+    lines.push("");
+    lines.push("Each TASK must satisfy:");
+    lines.push("");
+    lines.push("- **Small, verifiable scope**. One Builder finishes it in one Cursor session.");
+    lines.push("- **Self-contained**. A reader can determine the files to change and the Acceptance Criteria from the TASK body alone.");
+    lines.push("- **Explicit dependencies**. If TASK depends on another, write \"depends on TASK-NNN\" in Background.");
+    return lines.join("\n");
+}
+function fileFormat(inputs) {
+    const sections = REQUIRED_TASK_SECTIONS.map((s) => `   - \`## ${s}\``).join("\n");
+    return `## Output format
+
+Produce the response in this exact order:
+
+1. **Plan summary** — 5 to 8 bullets. Priorities / decomposition derived from the inputs.
+2. **TASK files** — each in its own fenced code block. The first line of each block must be \`<!-- file: docs/tasks/TASK-NNN-slug.md -->\` (an HTML comment) marking the path. Numbers increase sequentially from \`${inputs.nextTaskId}\`. Slugs are lowercase / ASCII / hyphen-separated (e.g. \`docs-and-readme\`).
+3. **Changed file list** — every \`docs/tasks/TASK-NNN-*.md\` path produced above.
+4. **Generated TASK summary** — table or bullet list: \`TASK-NNN · title · MVP Phase · one-line summary\`.
+5. **Assumptions** — items a human needs to reconfirm (use \`(none)\` if there are none).
+
+### Required sections per TASK file (same order, same heading text)
+
+Each TASK markdown begins with \`# ${inputs.nextTaskId} · <one-line title>\` and includes **all** of the following \`##\` sections:
+
+${sections}
+
+Additional rules:
+
+- The body of \`## Status\` is the single word \`planned\`.
+- The body of \`## MVP Phase\` follows \`${typeof inputs.phase === "string" && inputs.phase.length > 0 ? inputs.phase : "MVP <n> · <phase name>"}\` (or \`(unassigned)\` when unknown).
+- The body of \`## Git Context\` is \`(populated by \\\`vibeops task start TASK-NNN\\\`)\`.
+- The body of \`## Notion Page\` is \`(populated by \\\`vibeops notion sync\\\`)\`.
+- The body of \`## Result\` / \`## Test Result\` / \`## Review Notes\` is \`(not yet)\`.`;
+}
+function workflowReminders() {
+    return `## Workflow reminders
+
+- **VibeOps source of truth = \`docs/tasks/\` + \`docs/project/\` + Git.** Notion is a human dashboard and is never used for AI execution.
+- Once produced, each TASK must be ready for \`vibeops task start TASK-NNN\`. Keep slugs clean and numbers conflict-free.
+- Never produce application code — a separate Builder Agent does that in a different round.
+- Separate ambiguity into \`Risks\` (known unknowns) and \`Assumptions\` (need confirmation).`;
+}
+function fileSection(doc, fenceLang = "") {
+    if (doc.content === null) {
+        return `### \`${doc.relativePath}\` _(missing)_\n\n_(file not found — the Planner Agent must record this in Assumptions.)_`;
+    }
+    const fence = "```";
+    const lang = fenceLang.length > 0 ? fenceLang : "markdown";
+    return `### \`${doc.relativePath}\`\n\n${fence}${lang}\n${doc.content.trimEnd()}\n${fence}`;
+}
+function inlineInputs(docs) {
+    const parts = ["## Inline inputs"];
+    parts.push("");
+    parts.push("The code blocks below are the on-disk snapshot at prompt generation time. Cursor may open additional context, but **start from these**.");
+    parts.push("");
+    if (docs.from)
+        parts.push(fileSection(docs.from));
+    for (const slot of docs.slots)
+        parts.push(fileSection(slot));
+    parts.push(fileSection(docs.brief));
+    return parts.join("\n\n");
+}
+function footer() {
+    return `---
+
+Apply the rules above and produce the response. After you respond, a human reviews the generated \`docs/tasks/TASK-*.md\` files via \`git diff\` and commits them, then starts the first TASK with \`vibeops task start TASK-NNN\`.`;
+}
+export function buildTaskGeneratePrompt(inputs) {
+    return [
+        header(inputs),
+        role(),
+        hardRules(),
+        inventory(inputs.docs),
+        objective(inputs),
+        fileFormat(inputs),
+        workflowReminders(),
+        inlineInputs(inputs.docs),
+        footer(),
+    ].join("\n\n");
+}

package/dist/lib/task-prompt.js

@@ -0,0 +1,23 @@
+import { findAgent, listAgents } from "../agent/loader.js";
+import { buildPrompt } from "../agent/prompt.js";
+import { readConfig } from "./config.js";
+import { readText } from "./filesystem.js";
+import { readTaskFile } from "./task.js";
+export async function buildTaskPromptString(inputs) {
+    const agent = await findAgent(inputs.agentsDir, inputs.agentName);
+    if (!agent) {
+        const available = (await listAgents(inputs.agentsDir)).map((a) => a.meta.name);
+        return { ok: false, reason: "agent-not-found", available };
+    }
+    const config = await readConfig(inputs.projectRoot);
+    const meta = await readTaskFile(inputs.taskFilePath);
+    const body = await readText(inputs.taskFilePath);
+    const prompt = await buildPrompt({
+        agent,
+        config,
+        task: { meta, body },
+        projectRoot: inputs.projectRoot,
+        contextPaths: inputs.contextPaths ?? [],
+    });
+    return { ok: true, prompt };
+}