@goodtek/vibeops 0.7.22 → 1.1.1

package/dist/lib/task-pr-llm.js

@@ -0,0 +1,50 @@
+import { llmCompleteJson } from "./llm-complete.js";
+const SYSTEM = `You write pull/merge request titles and bodies for a software task.
+Output valid JSON only: { "title": string, "body": string }.
+Title: under 72 chars, include task id.
+Body: markdown with Summary, Changes, Test plan sections. Facts only from the input.`;
+export async function generateTaskPrWithLlm(input, cwd, preference) {
+    const user = [
+        `Task: ${input.taskId}`,
+        `Title: ${input.title}`,
+        `Base branch: ${input.baseBranch}`,
+        `Head branch: ${input.headBranch}`,
+        "",
+        "## TASK",
+        input.taskBody.slice(0, 12000),
+        "",
+        "## Diff summary",
+        input.diffSummary.slice(0, 8000) || "(no diff captured)",
+    ].join("\n");
+    const messages = [
+        { role: "system", content: SYSTEM },
+        { role: "user", content: user },
+    ];
+    try {
+        const { text: raw } = await llmCompleteJson(messages, { cwd, preference });
+        const parsed = JSON.parse(raw);
+        const prTitle = typeof parsed.title === "string" ? parsed.title.trim() : "";
+        const prBody = typeof parsed.body === "string" ? parsed.body.trim() : "";
+        if (!prTitle || !prBody)
+            return null;
+        return { prTitle, prBody };
+    }
+    catch {
+        return null;
+    }
+}
+export function fallbackTaskPr(input) {
+    const prTitle = `${input.taskId}: ${input.title}`.slice(0, 72);
+    const prBody = [
+        "## Summary",
+        input.title,
+        "",
+        "## Changes",
+        input.diffSummary || "(see commits on branch)",
+        "",
+        "## Test plan",
+        "- [ ] Run project test/lint commands",
+        "- [ ] Review TASK acceptance criteria",
+    ].join("\n");
+    return { prTitle, prBody };
+}

package/dist/lib/task-push-pr.js

@@ -0,0 +1,131 @@
+import { readText } from "./filesystem.js";
+import { readConfig } from "./config.js";
+import { detectGitHost, mergeRequestLabel } from "./git-host.js";
+import { requireGitConfig } from "./git-config.js";
+import { gitCommitsAhead, gitDiffNameOnly, gitLogOneline, gitPush, gitRemoteUrl, readGitInfo, } from "./git.js";
+import { dim, log } from "./logger.js";
+import { createMergeRequest, probeMergeRequestCli } from "./pr-create.js";
+import { fallbackTaskPr, generateTaskPrWithLlm } from "./task-pr-llm.js";
+import { readGitContext, readTaskFile, upsertGitContext } from "./task.js";
+async function buildDiffSummary(cwd, gitCtx) {
+    const files = await gitDiffNameOnly(cwd, `${gitCtx.baseCommit}..HEAD`);
+    const commits = await gitLogOneline(cwd, `${gitCtx.baseCommit}..HEAD`);
+    const lines = [];
+    if (commits.length > 0) {
+        lines.push("Commits:");
+        for (const c of commits.slice(0, 20)) {
+            lines.push(`- ${c.sha} ${c.message}`);
+        }
+        if (commits.length > 20)
+            lines.push(`- … and ${commits.length - 20} more`);
+    }
+    if (files.length > 0) {
+        lines.push("", "Files:");
+        for (const f of files.slice(0, 40))
+            lines.push(`- ${f}`);
+        if (files.length > 40)
+            lines.push(`- … and ${files.length - 40} more`);
+    }
+    return lines.join("\n") || "(no commits since task start)";
+}
+function isExistingMergeRequestUrl(url) {
+    if (typeof url !== "string" || url.length === 0)
+        return false;
+    return url.startsWith("http://") || url.startsWith("https://");
+}
+/** Push task branch and open MR/PR (idempotent when URL already in Git Context). */
+export async function finishTaskWithPullRequest(opts) {
+    let gitCfg = await requireGitConfig(opts.cwd);
+    const gitCtx = await readGitContext(opts.taskFile);
+    if (gitCtx === null) {
+        log.warn("No Git Context on TASK — push and merge request skipped.");
+        return { ok: true };
+    }
+    if (opts.dryRun) {
+        log.info(dim(`would git push -u ${gitCfg.remote} ${gitCtx.taskBranch} and open ${mergeRequestLabel(gitCfg.host)} → ${gitCtx.baseBranch}`));
+        return { ok: true, mergeRequestUrl: "(dry-run)" };
+    }
+    const remoteUrl = await gitRemoteUrl(opts.cwd, gitCfg.remote);
+    if (!remoteUrl) {
+        log.error(`Remote "${gitCfg.remote}" is not configured. Add it or re-run vibeops init.`);
+        return { ok: false };
+    }
+    const detectedHost = detectGitHost(remoteUrl);
+    if (detectedHost !== null && detectedHost !== gitCfg.host) {
+        log.warn(`Remote host (${detectedHost}) differs from .vibeops.json (${gitCfg.host}). Using ${detectedHost} for MR/PR.`);
+        gitCfg = { ...gitCfg, host: detectedHost };
+    }
+    const git = await readGitInfo(opts.cwd);
+    if (git.branch !== gitCtx.taskBranch) {
+        log.warn(`Current branch is ${git.branch ?? "(detached)"}, not ${gitCtx.taskBranch}. Push may fail.`);
+    }
+    if (isExistingMergeRequestUrl(gitCtx.mergeRequestUrl)) {
+        log.info(dim(`Merge request already recorded: ${gitCtx.mergeRequestUrl}`));
+        return { ok: true, mergeRequestUrl: gitCtx.mergeRequestUrl, pushed: true };
+    }
+    const ahead = await gitCommitsAhead(opts.cwd, gitCtx.baseCommit, "HEAD");
+    if (ahead === 0) {
+        log.warn("No commits ahead of base — pushing branch anyway.");
+    }
+    try {
+        await gitPush(opts.cwd, gitCfg.remote, gitCtx.taskBranch, true);
+        log.ok(`Pushed ${gitCtx.taskBranch} → ${gitCfg.remote}`);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        log.error(`git push failed: ${msg}`);
+        return { ok: false };
+    }
+    const pushedAt = new Date().toISOString();
+    if (opts.skipPr === true) {
+        await upsertGitContext(opts.taskFile, { ...gitCtx, pushedAt });
+        log.info(dim("Merge request creation skipped (--no-pr)."));
+        return { ok: true, pushed: true };
+    }
+    const cliOk = await probeMergeRequestCli(gitCfg.host);
+    if (!cliOk) {
+        const tool = gitCfg.host === "gitlab" ? "glab" : "gh";
+        await upsertGitContext(opts.taskFile, { ...gitCtx, pushedAt });
+        log.warn(`${tool} CLI not found — create the ${mergeRequestLabel(gitCfg.host)} manually: ${gitCtx.taskBranch} → ${gitCtx.baseBranch}`);
+        return { ok: true, pushed: true };
+    }
+    const config = await readConfig(opts.cwd);
+    const preference = config?.llm?.provider ?? "auto";
+    const meta = await readTaskFile(opts.taskFile);
+    const taskBody = await readText(opts.taskFile);
+    const diffSummary = await buildDiffSummary(opts.cwd, gitCtx);
+    const prInput = {
+        taskId: meta.id,
+        title: meta.title,
+        taskBody,
+        diffSummary,
+        baseBranch: gitCtx.baseBranch,
+        headBranch: gitCtx.taskBranch,
+    };
+    const llmPr = await generateTaskPrWithLlm(prInput, opts.cwd, preference);
+    const { prTitle, prBody } = llmPr ?? fallbackTaskPr(prInput);
+    try {
+        const { url } = await createMergeRequest({
+            cwd: opts.cwd,
+            host: gitCfg.host,
+            baseBranch: gitCtx.baseBranch,
+            headBranch: gitCtx.taskBranch,
+            title: prTitle,
+            body: prBody,
+        });
+        log.ok(`${mergeRequestLabel(gitCfg.host)}: ${url}`);
+        await upsertGitContext(opts.taskFile, {
+            ...gitCtx,
+            mergeRequestUrl: url,
+            pushedAt,
+        });
+        return { ok: true, mergeRequestUrl: url, pushed: true };
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        log.error(`Could not create merge request: ${msg}`);
+        await upsertGitContext(opts.taskFile, { ...gitCtx, pushedAt });
+        log.info(dim(`Branch was pushed. Create MR manually: ${gitCtx.taskBranch} → ${gitCtx.baseBranch}`));
+        return { ok: false, pushed: true };
+    }
+}

package/dist/lib/task-scaffold.js

@@ -1,5 +1,16 @@
 import { basename, join } from "node:path";
 import { statusDisplay } from "./task.js";
+export const V3_TASK_SECTIONS = [
+    "Status",
+    "Goal",
+    "Scope",
+    "Out of Scope",
+    "Acceptance Criteria",
+    "Test Plan",
+    "Git Context",
+    "Result",
+    "Test Result",
+];
 export function allocateNextTaskNumber(tasks) {
     let max = 0;
     for (const t of tasks) {
@@ -12,67 +23,37 @@ export function allocateNextTaskNumber(tasks) {
 export function formatTaskId(number) {
     return `TASK-${String(number).padStart(3, "0")}`;
 }
-export function buildWorkNowTaskMarkdown(draft) {
-    const spawnedNote = draft.spawnedFrom
-        ? `\n\nWork-now slice while **${draft.spawnedFrom}** is still open — not a pre-planned backlog item scheduled after later TASK numbers.`
-        : "";
+export function buildMinimalTaskMarkdown(draft) {
     return `# ${draft.id}: ${draft.title}
 
 ## Status
 
 ${statusDisplay("planned")}
 
-## MVP Phase
-
-${draft.mvpPhase}
-
 ## Goal
 
 ${draft.idea.trim()}
 
-## Background
-
-${draft.idea.trim()}${spawnedNote}
-
 ## Scope
 
 - Deliver the goal above in a single focused pass.
 
 ## Out of Scope
 
-- Unrelated backlog items and broad refactors not required for this slice.
+- Unrelated refactors and features outside this slice.
 
 ## Acceptance Criteria
 
-1. Goal and Scope are met and verifiable from the repo or commands in Test Plan.
-2. Result and Test Result sections are filled before \`vibeops done\`.
-
-## Files to Inspect First
-
-- (add paths before implementation)
-
-## Expected Files to Change
-
-- (list as you implement)
-
-## Risks
-
-- Scope creep from the parent TASK — keep this slice narrow.
+1. Goal and Scope are met and verifiable via Test Plan.
+2. Result and Test Result are filled before \`vibeops task done\`.
 
 ## Test Plan
 
-- \`vibeops task check ${draft.id}\`
-- Project-specific checks for the change
-
-## Rollback Plan
-
-- \`vibeops rollback ${draft.id}\` (advisory) or revert the task branch commits.
+- Project-specific checks for this change
 
-## Implementation Plan
+## Git Context
 
-1. Confirm Scope with the open parent TASK (if any).
-2. Implement on \`vibeops start ${draft.id}\`.
-3. Fill Result and Test Result, then \`vibeops done ${draft.id}\`.
+(populated by \`vibeops task add\`)
 
 ## Result
 
@@ -98,13 +79,28 @@ export function uniqueTaskPath(tasksDir, taskId, baseSlug, existingPaths) {
     }
     return { slug, filePath: join(tasksDir, name) };
 }
-export function titleFromIdea(idea, explicitTitle) {
-    const t = explicitTitle?.trim();
-    if (t && t.length > 0)
-        return t;
+export function titleFromIdea(idea) {
     const oneLine = idea.replace(/\s+/g, " ").trim();
     if (oneLine.length <= 80)
         return oneLine;
-    const cut = oneLine.slice(0, 77).trimEnd();
-    return `${cut}...`;
+    return `${oneLine.slice(0, 77).trimEnd()}...`;
+}
+export function ensureV3Sections(markdown) {
+    let body = markdown;
+    for (const section of V3_TASK_SECTIONS) {
+        const re = new RegExp(`^##\\s+${section.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*$`, "im");
+        if (!re.test(body)) {
+            body = `${body.trimEnd()}\n\n## ${section}\n\n(not yet)\n`;
+        }
+    }
+    return body;
+}
+export function normalizeTaskHeader(markdown, taskId, title) {
+    const lines = markdown.split("\n");
+    const header = `# ${taskId}: ${title}`;
+    if (lines.length > 0 && /^#\s+/.test(lines[0])) {
+        lines[0] = header;
+        return lines.join("\n");
+    }
+    return `${header}\n\n${markdown}`;
 }

package/dist/lib/task-start.js

@@ -0,0 +1,100 @@
+import { relative, resolve } from "node:path";
+import { branchNameForTaskFile, readGitContext, readTaskFile, updateInlineStatus, upsertGitContext, } from "./task.js";
+import { gitBranchExists, gitCheckout, gitCheckoutNewBranch, gitGovernanceOnlyDirty, gitHeadCommit, gitPullFastForwardOnly, gitRemoteBranchExists, gitSwitchToBranch, gitRemoteUrl, readGitInfo, } from "./git.js";
+import { cyan, dim, log } from "./logger.js";
+function relOrAbs(root, p) {
+    const r = relative(root, p);
+    return r === "" ? "." : r.startsWith("..") ? p : r;
+}
+/** Create or resume task branch from integration branch and mark TASK In Progress. */
+export async function startTaskBranch(opts) {
+    const cwd = resolve(opts.cwd);
+    const taskFile = opts.taskFile;
+    const integrationBranch = opts.integrationBranch;
+    const remote = opts.remote ?? "origin";
+    const meta = await readTaskFile(taskFile);
+    const git = await readGitInfo(cwd);
+    if (!git.isRepo) {
+        if (opts.dryRun) {
+            log.info(dim("dry-run — would require a git repository"));
+            return true;
+        }
+        log.error("Not a git repository. Run `vibeops init` with Git setup first.");
+        return false;
+    }
+    if (git.dirty === true && opts.allowDirty !== true) {
+        const gov = await gitGovernanceOnlyDirty(cwd);
+        if (!gov.onlyGovernance) {
+            log.error("Git working tree is dirty. Commit or stash, or rerun with --allow-dirty.");
+            return false;
+        }
+        log.warn("Only governance paths are dirty — proceeding.");
+    }
+    const taskBranch = branchNameForTaskFile(taskFile);
+    const existingCtx = await readGitContext(taskFile);
+    const branchExists = await gitBranchExists(cwd, taskBranch);
+    if (opts.dryRun) {
+        log.info(`  ${dim("integration")}  ${integrationBranch}`);
+        log.info(`  ${dim("task branch")}  ${cyan(taskBranch)}`);
+        log.info(dim(branchExists
+            ? `dry-run — would git switch ${taskBranch}`
+            : `dry-run — would checkout ${integrationBranch}, then git switch -c ${taskBranch}`));
+        return true;
+    }
+    if (!branchExists && git.branch !== integrationBranch) {
+        const ok = await gitSwitchToBranch(cwd, integrationBranch, remote);
+        if (!ok) {
+            log.error(`Integration branch "${integrationBranch}" not found locally or on ${remote}. Run vibeops init or create the branch.`);
+            return false;
+        }
+    }
+    // Ensure integration branch is up-to-date before creating a new task branch.
+    if (!branchExists) {
+        const remoteUrl = await gitRemoteUrl(cwd, remote);
+        if (remoteUrl) {
+            const hasRemoteBranch = await gitRemoteBranchExists(cwd, remote, integrationBranch);
+            if (hasRemoteBranch) {
+                try {
+                    await gitPullFastForwardOnly(cwd, remote, integrationBranch);
+                    log.info(dim(`Pulled latest ${remote}/${integrationBranch} (--ff-only).`));
+                }
+                catch {
+                    log.warn(`Could not fast-forward pull ${remote}/${integrationBranch}. Resolve manually, then rerun task add.`);
+                    return false;
+                }
+            }
+        }
+    }
+    const baseBranch = integrationBranch;
+    const baseCommit = (await gitHeadCommit(cwd)) ?? "";
+    if (baseCommit.length === 0 && !branchExists) {
+        log.error("No commits on integration branch. Create an initial commit first.");
+        return false;
+    }
+    const ctx = {
+        baseBranch,
+        baseCommit: branchExists && existingCtx ? existingCtx.baseCommit : baseCommit,
+        taskBranch,
+        startedAt: existingCtx?.startedAt ?? new Date().toISOString(),
+    };
+    log.info(`  ${dim("integration")}  ${baseBranch} @ ${ctx.baseCommit.slice(0, 7)}`);
+    log.info(`  ${dim("task branch")}  ${cyan(taskBranch)}`);
+    if (branchExists) {
+        await gitCheckout(cwd, taskBranch);
+        if (meta.status === "planned") {
+            await updateInlineStatus(taskFile, "in_progress");
+        }
+        if (existingCtx === null) {
+            await upsertGitContext(taskFile, ctx);
+        }
+        log.ok(`Resumed ${taskBranch}`);
+    }
+    else {
+        await gitCheckoutNewBranch(cwd, taskBranch, baseBranch);
+        await updateInlineStatus(taskFile, "in_progress");
+        await upsertGitContext(taskFile, ctx);
+        log.ok(`Branch ${taskBranch} ready`);
+    }
+    log.info(`  ${dim("file")}         ${relOrAbs(cwd, taskFile)}`);
+    return true;
+}

package/dist/lib/task-summary.js

@@ -1,27 +1,12 @@
-/**
- * Small text-extraction helpers used by `vibeops notion sync` and
- * `vibeops task pull`.
- *
- * Everything here is read-only (`extract*`) or returns new strings the caller
- * may write back (`upsertNotionPageSection`, `renderPulledTaskMarkdown`).
- *
- * Goal/Background extraction is deliberately heuristic:
- *   - we strip markdown bullet/numbering prefixes,
- *   - we collapse blank-line groups so the first non-empty paragraph wins,
- *   - we truncate to `NOTION_TEXT_LIMIT` (default 1500 chars).
- *
- * We never include placeholder content such as `(not yet)`, legacy localized
- * placeholders, or `(scaffolded ...)`; those become an empty string.
- */
-import { readTextOrNull, writeText } from "./filesystem.js";
 import { isPlaceholderContent, readSection } from "./task.js";
-import { truncate } from "./notion-mappers.js";
-const PLACEHOLDER_RE = new RegExp(String.raw `^\(.*(not yet|fill in|unassigned|scaffold|\uBBF8\uC218\uD589|\uBBF8\uC815|\uCC44\uC6CC\uB77C).*\)$`, "i");
+const PLACEHOLDER_RE = new RegExp(String.raw `^\(.*(not yet|fill in|unassigned|scaffold|\uBBF8\uC218\uD589).*\)$`, "i");
 function stripBullet(line) {
     return line.replace(/^\s*(?:[-*+]|\d+\.)\s+/, "").trim();
 }
-function isHeading(line) {
-    return /^#{1,6}\s+/.test(line);
+function truncate(text, limit) {
+    if (text.length <= limit)
+        return text;
+    return `${text.slice(0, limit - 1)}…`;
 }
 function compressBlank(lines) {
     const out = [];
@@ -39,19 +24,12 @@ function compressBlank(lines) {
     }
     return out.join("\n").trim();
 }
-/**
- * Pull a flattened, single-string summary from a `## Section`. Bullet points
- * and numbered list items are joined with " · ". Placeholder bodies become "".
- */
-export function summarizeSection(body, title, limit) {
+export function summarizeSection(body, title, limit = 280) {
     const raw = readSection(body, title);
-    if (raw.length === 0)
+    if (raw.length === 0 || isPlaceholderContent(raw))
         return "";
-    if (isPlaceholderContent(raw))
-        return "";
-    const lines = raw.split("\n");
     const cleaned = [];
-    for (const line of lines) {
+    for (const line of raw.split("\n")) {
         const t = line.trim();
         if (t.length === 0) {
             cleaned.push("");
@@ -59,218 +37,13 @@ export function summarizeSection(body, title, limit) {
         }
         if (PLACEHOLDER_RE.test(t))
             continue;
-        if (isHeading(t))
+        if (/^#{1,6}\s+/.test(t))
             continue;
         cleaned.push(stripBullet(t));
     }
-    const compact = compressBlank(cleaned);
-    return truncate(compact, limit);
+    return truncate(compressBlank(cleaned), limit);
 }
-export function summarizeGoal(body, limit) {
+export function summarizeGoal(body, limit = 280) {
     const goal = summarizeSection(body, "Goal", limit);
-    if (goal.length > 0)
-        return goal;
-    return summarizeSection(body, "Background", limit);
-}
-export function summarizeResult(body, limit) {
-    return summarizeSection(body, "Result", limit);
-}
-/**
- * Best-effort: pull the very first non-heading paragraph from an arbitrary
- * markdown body (e.g. `docs/project/00-overview.md`). Returns "" if nothing
- * useful is found.
- */
-export function summarizeMarkdownLead(body, limit) {
-    const lines = body.split("\n");
-    const collected = [];
-    let started = false;
-    for (const raw of lines) {
-        const t = raw.trim();
-        if (t.length === 0) {
-            if (started)
-                break;
-            continue;
-        }
-        if (isHeading(t)) {
-            if (started)
-                break;
-            continue;
-        }
-        if (t.startsWith(">"))
-            continue;
-        started = true;
-        collected.push(stripBullet(t));
-    }
-    return truncate(collected.join(" ").trim(), limit);
-}
-/**
- * Heuristic: scan `docs/project/05-current-state.md` (or any markdown) for an
- * "MVP 1 ~ N" hint. Falls back to the first heading-derived MVP token.
- */
-export function detectCurrentPhase(body) {
-    if (body.length === 0)
-        return "";
-    const m = body.match(/MVP\s*\d+(?:\s*[·•:\-]\s*[^\n]+)?/i);
-    if (m)
-        return m[0].trim().replace(/\s+/g, " ");
-    return "";
-}
-export function renderNotionPageBlock(inputs) {
-    return [
-        `- Page ID: \`${inputs.pageId}\``,
-        `- Docs Path: \`${inputs.docsRelativePath}\``,
-    ].join("\n");
-}
-const NOTION_PAGE_RE = /^-\s+Page ID:\s*`([^`]+)`/m;
-export function readNotionPageId(body) {
-    const section = readSection(body, "Notion Page");
-    if (section.length === 0)
-        return null;
-    const m = section.match(NOTION_PAGE_RE);
-    return m ? m[1].trim() : null;
-}
-/**
- * Replace the body of an existing `## Notion Page` section, or append the
- * section to the file if it doesn't exist yet. Returns the new file body
- * (caller is responsible for writing it back).
- */
-export function upsertNotionPageSection(body, inputs) {
-    const block = renderNotionPageBlock(inputs);
-    const HEADING_RE = /^(##+)\s+(.+?)\s*$/;
-    const lines = body.split("\n");
-    let startIdx = -1;
-    let endIdx = -1;
-    let level = 2;
-    for (let i = 0; i < lines.length; i++) {
-        const m = HEADING_RE.exec(lines[i]);
-        if (!m)
-            continue;
-        if (m[2].trim().toLowerCase() !== "notion page")
-            continue;
-        startIdx = i;
-        level = m[1].length;
-        let j = i + 1;
-        while (j < lines.length) {
-            const nm = HEADING_RE.exec(lines[j]);
-            if (nm && nm[1].length <= level)
-                break;
-            j++;
-        }
-        endIdx = j;
-        break;
-    }
-    if (startIdx < 0) {
-        const trimmed = body.replace(/\s+$/u, "");
-        return `${trimmed}\n\n## Notion Page\n\n${block}\n`;
-    }
-    const before = lines.slice(0, startIdx + 1);
-    const after = lines.slice(endIdx);
-    return [...before, "", block, "", ...after].join("\n").replace(/\n{3,}/g, "\n\n");
-}
-export async function writeNotionPageSection(filePath, inputs) {
-    const current = await readTextOrNull(filePath);
-    if (current === null)
-        return false;
-    const next = upsertNotionPageSection(current, inputs);
-    if (next === current)
-        return false;
-    await writeText(filePath, next);
-    return true;
-}
-/**
- * Render the markdown body for a TASK file that `vibeops task pull` is
- * creating from a Notion row. Always uses the 18-section skeleton so the
- * downstream `vibeops task done` validation can still run.
- *
- * Only the fields Notion actually carries get prefilled; everything else
- * stays a placeholder.
- */
-export function renderPulledTaskMarkdown(inputs) {
-    const title = inputs.title.length > 0 ? inputs.title : "(pulled from Notion — fill in)";
-    const status = inputs.status.length > 0 ? inputs.status : "planned";
-    const phase = inputs.mvpPhase.length > 0 ? inputs.mvpPhase : "(unassigned)";
-    const summary = inputs.summary.length > 0 ? inputs.summary : "(Notion Summary is empty — fill in.)";
-    const notionBlock = renderNotionPageBlock({
-        pageId: inputs.pageId,
-        docsRelativePath: inputs.docsRelativePath,
-    });
-    return `# ${inputs.taskId} · ${title}
-
-> This file was generated by \`vibeops task pull\` from Notion metadata. The body is empty — the Builder/Planner Agent should fill it in.
-
-## Status
-
-${status}
-
-## MVP Phase
-
-${phase}
-
-## Goal
-
-${summary}
-
-## Background
-
-(pulled — fill in context beyond the Notion Summary.)
-
-## Scope
-
-- (pulled — Scope item 1)
-- (pulled — Scope item 2)
-
-## Out of Scope
-
-- (pulled)
-
-## Acceptance Criteria
-
-1. (pulled — verifiable statement 1)
-2. (pulled — verifiable statement 2)
-
-## Files to Inspect First
-
-- (pulled)
-
-## Expected Files to Change
-
-- new: (pulled)
-- update: (pulled)
-
-## Risks
-
-- (pulled)
-
-## Test Plan
-
-- (pulled)
-
-## Rollback Plan
-
-- (pulled)
-
-## Git Context
-
-(populated by \`vibeops task start ${inputs.taskId}\`)
-
-## Notion Page
-
-${notionBlock}
-
-## Implementation Plan
-
-1. (pulled)
-
-## Result
-
-(not yet)
-
-## Test Result
-
-(not yet)
-
-## Review Notes
-
-(not yet)
-`;
+    return goal.length > 0 ? goal : summarizeSection(body, "Scope", limit);
 }