@goodtek/vibeops 0.4.0 → 1.0.0

package/dist/commands/task-done.js

@@ -1,98 +1,141 @@
-import { relative, resolve } from "node:path";
+import { resolve } from "node:path";
+import { askYesNo } from "../lib/inquirer-helpers.js";
 import { readText } from "../lib/filesystem.js";
 import { bold, cyan, dim, green, log, yellow } from "../lib/logger.js";
 import { projectPaths } from "../lib/paths.js";
-import { findTaskFile, hasNonEmptySection, parseTaskFilename, pickNextTask, readGitContext, readTaskFile, scanTasks, statusDisplay, updateInlineStatus, } from "../lib/task.js";
-function relOrAbs(root, p) {
-    const r = relative(root, p);
-    return r === "" ? "." : r.startsWith("..") ? p : r;
+import { resolveTask, taskNotFoundMessage } from "../lib/resolve-task.js";
+import { mergeTaskBranch } from "../lib/task-merge.js";
+import { applyTaskDoneMemory, fallbackResultSections, llmCompleteTaskDone, writeTaskResultSections, } from "../lib/task-done-llm.js";
+import { relPath } from "../lib/task-context.js";
+import { gitAddPaths, listWorkingTreeRelPaths, partitionPathsForAutoCommit, readGitInfo, runGit, } from "../lib/git.js";
+import { hasNonEmptySection, markGitContextDone, parseTaskFilename, readGitContext, readTaskFile, updateInlineStatus, } from "../lib/task.js";
+function commitMessageFor(taskId, title) {
+    const slug = title.replace(/^TASK-\d+\s*[:\-]\s*/i, "").trim() || taskId;
+    return `feat(${taskId.toLowerCase()}): ${slug}`;
 }
-function commitMessageFor(taskId, title, mvpPhase) {
-    const trimmed = (title || taskId).trim();
-    const slug = trimmed.replace(/^TASK-\d+\s*[·:\-]\s*/i, "").trim() || trimmed;
-    const scope = taskId.toLowerCase();
-    const typePrefix = typeof mvpPhase === "string" && /rollback/i.test(mvpPhase) ? "chore" : "feat";
-    return `${typePrefix}(${scope}): ${slug}`;
+async function tryCommitDirty(cwd, message, dryRun) {
+    const git = await readGitInfo(cwd);
+    if (!git.isRepo || git.dirty !== true)
+        return false;
+    const { committable, excluded } = partitionPathsForAutoCommit(await listWorkingTreeRelPaths(cwd), { unmerged: [] });
+    if (committable.length === 0)
+        return false;
+    if (excluded.length > 0) {
+        log.warn(`Skipping ${excluded.length} build artifact path(s) from auto-commit.`);
+    }
+    if (dryRun) {
+        log.info(dim(`  would commit ${committable.length} path(s)`));
+        return true;
+    }
+    await gitAddPaths(cwd, committable);
+    await runGit(cwd, ["commit", "-q", "-m", message]);
+    log.ok(`Committed: ${message}`);
+    return true;
 }
-export async function taskDoneCommand(taskId, options = {}) {
+export async function taskDoneCommand(taskRef, options = {}) {
     const cwd = resolve(options.cwd ?? process.cwd());
     const paths = projectPaths(cwd);
-    const taskFile = await findTaskFile(paths.docsTasks, taskId);
-    if (!taskFile) {
-        log.error(`TASK not found: ${taskId} (looked in ${relOrAbs(cwd, paths.docsTasks)})`);
+    const dryRun = options.dryRun === true;
+    const interactive = !dryRun && process.stdin.isTTY === true && options.yes !== true;
+    const resolved = await resolveTask(paths, cwd, taskRef);
+    if (resolved === null) {
+        log.error(taskNotFoundMessage(taskRef));
         process.exitCode = 1;
         return;
     }
+    const { taskId, taskFile } = resolved;
     const meta = await readTaskFile(taskFile);
     const body = await readText(taskFile);
-    log.info(bold(`vibeops task done ${meta.id}`));
-    log.info(`  ${dim("file")}    ${relOrAbs(cwd, taskFile)}`);
-    log.info(`  ${dim("title")}   ${meta.title || dim("(no title)")}`);
-    log.info(`  ${dim("status")}  ${statusDisplay(meta.status)}`);
+    const relFile = relPath(cwd, taskFile);
+    log.info(bold(`vibeops task done ${taskId}`));
+    log.info(`  ${dim("file")}  ${relFile}`);
     log.blank();
-    const resultOk = hasNonEmptySection(body, "Result");
-    const testResultOk = hasNonEmptySection(body, "Test Result");
-    const docCheck = [
-        ["Result section", resultOk],
-        ["Test Result section", testResultOk],
-    ];
-    log.info(bold("Required sections"));
-    let missing = 0;
-    for (const [label, ok] of docCheck) {
-        if (!ok)
-            missing++;
-        log.info(`  ${ok ? green("✓") : yellow("·")} ${label}${ok ? "" : dim(" (empty or placeholder)")}`);
+    let resultOk = hasNonEmptySection(body, "Result");
+    let testOk = hasNonEmptySection(body, "Test Result");
+    if (!resultOk || !testOk) {
+        log.step("LLM — Result / Test Result + project memory");
+        if (dryRun) {
+            log.info(dim("  would call LLM and patch docs/project/*"));
+        }
+        else {
+            const patch = await llmCompleteTaskDone({
+                cwd,
+                taskId,
+                taskTitle: meta.title,
+                taskBody: body,
+                taskFileRel: relFile,
+            });
+            if (patch !== null) {
+                await writeTaskResultSections(taskFile, patch.result, patch.testResult);
+                log.ok(`Result / Test Result updated (${patch.provider})`);
+                const memory = await applyTaskDoneMemory(cwd, patch);
+                for (const p of memory.updated)
+                    log.ok(`Updated ${p}`);
+                for (const p of memory.skipped)
+                    log.skip(`Skipped ${p}`);
+            }
+            else {
+                log.warn("LLM unavailable — using git diff fallback for Result sections.");
+                const fb = await fallbackResultSections(cwd, taskId, taskFile);
+                await writeTaskResultSections(taskFile, fb.result, fb.testResult);
+            }
+        }
+        const body2 = dryRun ? body : await readText(taskFile);
+        resultOk = hasNonEmptySection(body2, "Result");
+        testOk = hasNonEmptySection(body2, "Test Result");
     }
+    log.info(bold("Sections"));
+    log.info(`  ${resultOk ? green("✓") : yellow("·")} Result`);
+    log.info(`  ${testOk ? green("✓") : yellow("·")} Test Result`);
     log.blank();
-    if (missing > 0) {
-        log.error(`${missing} required section(s) still empty. Fill Result / Test Result first, then re-run \`vibeops task done\`.`);
+    if (!dryRun && (!resultOk || !testOk)) {
+        log.error("Fill Result and Test Result in the TASK file, then rerun.");
         process.exitCode = 1;
         return;
     }
-    const target = options.finalize === true ? "done" : "review";
-    const targetDisplay = statusDisplay(target);
-    if (options.dryRun === true) {
-        log.info(bold("dry-run — would perform:"));
-        log.info(`  · update Status → ${targetDisplay} in ${relOrAbs(cwd, taskFile)}`);
-        log.info(`  · (no git commit, no Notion call)`);
-        log.blank();
-    }
-    else {
-        await updateInlineStatus(taskFile, target);
-        log.ok(`Status → ${targetDisplay}  (${relOrAbs(cwd, taskFile)})`);
-        log.blank();
+    if (dryRun) {
+        log.info(bold("dry-run — would:"));
+        if (!resultOk || !testOk) {
+            log.info("  · LLM fill Result / Test Result + patch docs/project/*");
+        }
+        log.info("  · Status → Done");
+        log.info("  · commit if dirty, merge task branch (unless --no-merge)");
+        return;
     }
-    const ctx = await readGitContext(taskFile);
+    await updateInlineStatus(taskFile, "done");
+    await markGitContextDone(taskFile);
+    log.ok("Status → Done");
     const parts = parseTaskFilename(taskFile);
-    const commitMsg = commitMessageFor(parts.id, meta.title, meta.mvpPhase);
-    log.info(bold("Suggested commit"));
-    log.info(`  ${cyan(`git add -A && git commit -m "${commitMsg}"`)}`);
-    if (ctx !== null) {
-        log.info(`  ${dim(`after commit on ${ctx.taskBranch}: open PR or run \`git switch ${ctx.baseBranch} && git merge --no-ff ${ctx.taskBranch}\``)}`);
-    }
-    else {
-        log.info(`  ${dim("(no Git Context section — skipping merge guidance)")}`);
+    const commitMsg = commitMessageFor(parts.id, meta.title);
+    await tryCommitDirty(cwd, commitMsg, false);
+    const gitCtx = await readGitContext(taskFile);
+    if (options.noMerge !== true && gitCtx !== null) {
+        let doMerge = options.yes === true || !interactive;
+        if (interactive) {
+            doMerge = await askYesNo({
+                message: `Merge into ${gitCtx.baseBranch} and delete ${gitCtx.taskBranch}?`,
+                nonInteractive: false,
+                defaultValue: true,
+            });
+        }
+        if (doMerge) {
+            const mergeResult = await mergeTaskBranch({
+                cwd,
+                taskId: meta.id,
+                taskTitle: meta.title,
+                gitCtx,
+                allowDirty: options.allowDirty,
+            });
+            if (!mergeResult.ok)
+                process.exitCode = 1;
+        }
+        else {
+            log.info(dim("Merge skipped."));
+        }
     }
-    log.blank();
-    log.info(bold("Notion"));
-    log.info(`  ${dim("TODO: run `vibeops notion sync` to push this TASK metadata.")}`);
-    log.blank();
-    const all = await scanTasks(paths.docsTasks);
-    const next = pickNextTask(all.filter((t) => t.id.toUpperCase() !== meta.id.toUpperCase()));
-    log.info(bold("Next TASK candidate"));
-    if (next) {
-        log.info(`  → ${cyan(next.id)} — ${next.title || dim("(no title)")}  ${dim(`[${statusDisplay(next.status)}]`)}`);
-        log.info(`    file: ${dim(relOrAbs(cwd, next.filePath))}`);
-        log.info(`    start: ${dim(`vibeops task start ${next.id}`)}`);
-    }
-    else {
-        log.info(`  ${dim("(no remaining planned / in-progress / review TASK)")}`);
+    else if (gitCtx === null) {
+        log.info(dim("No Git Context — merge skipped."));
     }
     log.blank();
-    if (target === "review") {
-        log.info(`Status moved to ${cyan("Review")}. After human or Reviewer Agent review, finalize with ${cyan(`vibeops task done ${meta.id} --finalize`)}.`);
-    }
-    else {
-        log.ok(`${meta.id} finalized → Done.`);
-    }
+    log.info(`Next: ${cyan("vibeops task add")} or ${cyan("vibeops status")}`);
 }

package/dist/lib/config.js

@@ -2,39 +2,7 @@ import { join } from "node:path";
 import { readTextOrNull, writeText } from "./filesystem.js";
 import { VIBEOPS_CONFIG_FILE } from "./paths.js";
 import { VERSION } from "../version.js";
-import { DEFAULT_GITHUB_CONFIG, VIBEOPS_CONFIG_SCHEMA_VERSION, } from "../types/config.js";
-function parseNotionSection(raw) {
-    if (raw === null || typeof raw !== "object")
-        return undefined;
-    const r = raw;
-    const out = {
-        enabled: typeof r.enabled === "boolean" ? r.enabled : false,
-        projectsTargetId: typeof r.projectsTargetId === "string" ? r.projectsTargetId : "",
-        tasksTargetId: typeof r.tasksTargetId === "string" ? r.tasksTargetId : "",
-        projectsDatabaseId: typeof r.projectsDatabaseId === "string" ? r.projectsDatabaseId : "",
-        tasksDatabaseId: typeof r.tasksDatabaseId === "string" ? r.tasksDatabaseId : "",
-    };
-    return out;
-}
-function parseGithubVisibility(raw) {
-    if (raw === "public" || raw === "private")
-        return raw;
-    return "";
-}
-function parseGithubSection(raw) {
-    if (raw === null || typeof raw !== "object")
-        return undefined;
-    const r = raw;
-    return {
-        enabled: typeof r.enabled === "boolean" ? r.enabled : false,
-        mode: r.mode === "gh-cli" ? "gh-cli" : "gh-cli",
-        owner: typeof r.owner === "string" ? r.owner : "",
-        repo: typeof r.repo === "string" ? r.repo : "",
-        remote: typeof r.remote === "string" && r.remote.length > 0 ? r.remote : "origin",
-        visibility: parseGithubVisibility(r.visibility),
-        url: typeof r.url === "string" ? r.url : "",
-    };
-}
+import { VIBEOPS_CONFIG_SCHEMA_VERSION } from "../types/config.js";
 export async function readConfig(root) {
     const text = await readTextOrNull(join(root, VIBEOPS_CONFIG_FILE));
     if (text === null)
@@ -45,19 +13,12 @@ export async function readConfig(root) {
             typeof parsed.vibeopsVersion === "string" &&
             typeof parsed.createdAt === "string" &&
             parsed.schemaVersion === VIBEOPS_CONFIG_SCHEMA_VERSION) {
-            const notion = parseNotionSection(parsed.notion);
-            const github = parseGithubSection(parsed.github);
-            const config = {
+            return {
                 name: parsed.name,
                 vibeopsVersion: parsed.vibeopsVersion,
                 schemaVersion: VIBEOPS_CONFIG_SCHEMA_VERSION,
                 createdAt: parsed.createdAt,
             };
-            if (notion)
-                config.notion = notion;
-            if (github)
-                config.github = github;
-            return config;
         }
         return null;
     }
@@ -79,80 +40,3 @@ export function configToJson(config) {
 export async function writeConfig(root, config) {
     await writeText(join(root, VIBEOPS_CONFIG_FILE), configToJson(config));
 }
-/** Merge a partial notion section into an existing config without touching other fields. */
-export function mergeNotionConfig(base, patch) {
-    const current = base.notion ?? {
-        enabled: false,
-        projectsTargetId: "",
-        tasksTargetId: "",
-        projectsDatabaseId: "",
-        tasksDatabaseId: "",
-    };
-    const next = {
-        enabled: patch.enabled ?? current.enabled,
-        projectsTargetId: patch.projectsTargetId !== undefined && patch.projectsTargetId.length > 0
-            ? patch.projectsTargetId
-            : current.projectsTargetId,
-        tasksTargetId: patch.tasksTargetId !== undefined && patch.tasksTargetId.length > 0
-            ? patch.tasksTargetId
-            : current.tasksTargetId,
-        projectsDatabaseId: patch.projectsDatabaseId !== undefined && patch.projectsDatabaseId.length > 0
-            ? patch.projectsDatabaseId
-            : current.projectsDatabaseId,
-        tasksDatabaseId: patch.tasksDatabaseId !== undefined && patch.tasksDatabaseId.length > 0
-            ? patch.tasksDatabaseId
-            : current.tasksDatabaseId,
-    };
-    const changed = base.notion === undefined ||
-        next.enabled !== current.enabled ||
-        next.projectsTargetId !== current.projectsTargetId ||
-        next.tasksTargetId !== current.tasksTargetId ||
-        next.projectsDatabaseId !== current.projectsDatabaseId ||
-        next.tasksDatabaseId !== current.tasksDatabaseId;
-    return { merged: { ...base, notion: next }, changed };
-}
-/** Preferred Projects target id for API calls: data_source target first, legacy DB fallback. */
-export function notionProjectsTargetId(notion) {
-    return notion.projectsTargetId.length > 0
-        ? notion.projectsTargetId
-        : notion.projectsDatabaseId;
-}
-/** Preferred Tasks target id for API calls: data_source target first, legacy DB fallback. */
-export function notionTasksTargetId(notion) {
-    return notion.tasksTargetId.length > 0 ? notion.tasksTargetId : notion.tasksDatabaseId;
-}
-/**
- * Merge a partial github section into an existing config without touching
- * other fields (notion, name, etc.). Empty strings in the patch are treated
- * as "no value provided" — the existing value is kept. Pass through
- * `enabled` / `mode` always (booleans / enums always overwrite).
- */
-export function mergeGithubConfig(base, patch) {
-    const current = base.github ?? DEFAULT_GITHUB_CONFIG;
-    const next = {
-        enabled: patch.enabled ?? current.enabled,
-        mode: patch.mode ?? current.mode,
-        owner: patch.owner !== undefined && patch.owner.length > 0
-            ? patch.owner
-            : current.owner,
-        repo: patch.repo !== undefined && patch.repo.length > 0
-            ? patch.repo
-            : current.repo,
-        remote: patch.remote !== undefined && patch.remote.length > 0
-            ? patch.remote
-            : current.remote,
-        visibility: patch.visibility !== undefined && patch.visibility.length > 0
-            ? patch.visibility
-            : current.visibility,
-        url: patch.url !== undefined && patch.url.length > 0 ? patch.url : current.url,
-    };
-    const changed = base.github === undefined ||
-        next.enabled !== current.enabled ||
-        next.mode !== current.mode ||
-        next.owner !== current.owner ||
-        next.repo !== current.repo ||
-        next.remote !== current.remote ||
-        next.visibility !== current.visibility ||
-        next.url !== current.url;
-    return { merged: { ...base, github: next }, changed };
-}

package/dist/lib/git.js

@@ -1,6 +1,9 @@
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
+import { dim, log } from "./logger.js";
 const exec = promisify(execFile);
+/** Avoid `maxBuffer` errors on large `git commit` / `git add` output. */
+const DEFAULT_GIT_MAX_BUFFER = 64 * 1024 * 1024;
 async function tryGit(cwd, args) {
     try {
         const { stdout } = await exec("git", args, { cwd });
@@ -10,8 +13,11 @@ async function tryGit(cwd, args) {
         return null;
     }
 }
-export async function runGit(cwd, args) {
-    const { stdout, stderr } = await exec("git", args, { cwd });
+export async function runGit(cwd, args, options = {}) {
+    const { stdout, stderr } = await exec("git", args, {
+        cwd,
+        maxBuffer: options.maxBuffer ?? DEFAULT_GIT_MAX_BUFFER,
+    });
     return { stdout, stderr };
 }
 export async function isGitRepository(cwd) {
@@ -83,14 +89,90 @@ export async function gitCreateBranch(cwd, name, startPoint) {
         args.push(startPoint);
     await runGit(cwd, args);
 }
+/**
+ * When only governance / VibeOps paths are dirty, stash them so `git switch` can proceed.
+ * Callers that switch branches should restore with {@link restoreGovernanceStashAfterSwitch}.
+ */
+export async function stashGovernanceIfBlocking(cwd) {
+    const git = await readGitInfo(cwd);
+    if (git.dirty !== true)
+        return false;
+    const gov = await gitGovernanceOnlyDirty(cwd);
+    if (!gov.onlyGovernance || gov.allPaths.length === 0)
+        return false;
+    const entries = parsePorcelain(await gitStatusPorcelain(cwd));
+    const tracked = [];
+    const untracked = [];
+    for (const e of entries) {
+        if (!isGovernanceDocumentationPath(e.path))
+            continue;
+        if (e.untracked)
+            untracked.push(e.path);
+        else
+            tracked.push(e.path);
+    }
+    let didStash = false;
+    if (tracked.length > 0) {
+        await runGit(cwd, [
+            "stash",
+            "push",
+            "-m",
+            "vibeops: governance before branch switch",
+            "--",
+            ...tracked,
+        ]);
+        didStash = true;
+    }
+    if (untracked.length > 0) {
+        try {
+            await runGit(cwd, [
+                "stash",
+                "push",
+                "-u",
+                "-m",
+                "vibeops: governance untracked before branch switch",
+                "--",
+                ...untracked,
+            ]);
+            didStash = true;
+        }
+        catch {
+            // Untracked generated files (e.g. cursor-implement-*.md) may not stash; switch can still proceed.
+        }
+    }
+    return didStash;
+}
+/** Re-apply governance paths stashed for a branch switch (e.g. new `docs/tasks/*.md`). */
+export async function restoreGovernanceStashAfterSwitch(cwd, didStash) {
+    if (!didStash)
+        return;
+    try {
+        await runGit(cwd, ["stash", "pop"]);
+        log.info(dim("Restored stashed governance paths on the task branch."));
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        log.warn(`Could not restore stashed governance files (${msg}). Run ${dim("git stash pop")} manually.`);
+    }
+}
 export async function gitCheckout(cwd, ref) {
-    await runGit(cwd, ["checkout", ref]);
+    const stashed = await stashGovernanceIfBlocking(cwd);
+    if (stashed) {
+        log.info(dim("Stashed governance-only changes (.vibeops/, docs/) before branch switch."));
+    }
+    await runGit(cwd, ["switch", ref]);
+    await restoreGovernanceStashAfterSwitch(cwd, stashed);
 }
 export async function gitCheckoutNewBranch(cwd, name, startPoint) {
-    const args = ["checkout", "-b", name];
+    const stashed = await stashGovernanceIfBlocking(cwd);
+    if (stashed) {
+        log.info(dim("Stashed governance-only changes (.vibeops/, docs/) before branch switch."));
+    }
+    const args = ["switch", "-c", name];
     if (typeof startPoint === "string" && startPoint.length > 0)
         args.push(startPoint);
     await runGit(cwd, args);
+    await restoreGovernanceStashAfterSwitch(cwd, stashed);
 }
 export async function gitDeleteBranch(cwd, name, opts = {}) {
     const flag = opts.force === true ? "-D" : "-d";
@@ -167,12 +249,12 @@ function parsePorcelain(lines) {
     }
     return out;
 }
-/** Paths under these prefixes may stay uncommitted across `task done` / doc updates. */
+/** Paths under these prefixes may stay uncommitted across `start` / `done` / doc updates. */
 const GOVERNANCE_DOC_REL_PREFIXES = [
     "docs/tasks/",
     "docs/project/",
     "docs/logs/",
-    ".vibeops/state/",
+    ".vibeops/",
 ];
 function normalizeRepoRelPath(p) {
     return p.replace(/\\/g, "/").replace(/^\/+/, "");
@@ -185,10 +267,110 @@ export function isGovernanceDocumentationPath(repoRelativePath) {
     }
     return false;
 }
+/** Build artifacts / deps — never auto-committed by `vibeops done` cleanup. */
+const AUTO_COMMIT_EXCLUDED_PREFIXES = [
+    "node_modules/",
+    ".next/",
+    ".pnpm-store/",
+    "dist/",
+    "build/",
+    ".turbo/",
+    "coverage/",
+    ".vercel/",
+    ".output/",
+    ".cache/",
+];
+const AUTO_COMMIT_EXCLUDED_EXACT = new Set([
+    "node_modules",
+    ".next",
+    "dist",
+    "build",
+]);
+export function isAutoCommitExcludedPath(repoRelativePath) {
+    const n = normalizeRepoRelPath(repoRelativePath);
+    if (AUTO_COMMIT_EXCLUDED_EXACT.has(n))
+        return true;
+    for (const prefix of AUTO_COMMIT_EXCLUDED_PREFIXES) {
+        if (n.startsWith(prefix))
+            return true;
+    }
+    return false;
+}
+export async function gitMergeInProgress(cwd) {
+    return (await tryGit(cwd, ["rev-parse", "-q", "--verify", "MERGE_HEAD"])) !== null;
+}
+/** Conflict paths from an in-progress merge (`git diff --diff-filter=U`). */
+export async function listUnmergedRelPaths(cwd) {
+    const res = await tryGit(cwd, ["diff", "--name-only", "--diff-filter=U"]);
+    if (res === null)
+        return [];
+    return res.stdout
+        .split("\n")
+        .map((p) => p.trim())
+        .filter((p) => p.length > 0);
+}
+/**
+ * During a merge, take the incoming branch version for governance / VibeOps paths
+ * (typical after `vibeops done` merge conflicts on `.vibeops/generated/*`).
+ */
+export async function tryResolveGovernanceUnmerged(cwd) {
+    const unmerged = await listUnmergedRelPaths(cwd);
+    const resolved = [];
+    for (const p of unmerged) {
+        if (!isGovernanceDocumentationPath(p))
+            continue;
+        try {
+            await runGit(cwd, ["checkout", "--theirs", "--", p]);
+            await runGit(cwd, ["add", "--", p]);
+            resolved.push(p);
+        }
+        catch {
+            // skip paths that cannot be auto-resolved
+        }
+    }
+    return resolved;
+}
+export async function listWorkingTreeRelPaths(cwd) {
+    const entries = parsePorcelain(await gitStatusPorcelain(cwd));
+    const all = new Set();
+    for (const e of entries) {
+        all.add(e.path);
+        if (typeof e.origPath === "string" && e.origPath.length > 0) {
+            all.add(e.origPath);
+        }
+    }
+    return [...all];
+}
+export function partitionPathsForAutoCommit(paths, opts = {}) {
+    const unmergedSet = new Set(opts.unmerged ?? []);
+    const committable = [];
+    const excluded = [];
+    const unmerged = [];
+    for (const p of paths) {
+        if (unmergedSet.has(p)) {
+            unmerged.push(p);
+            continue;
+        }
+        if (isAutoCommitExcludedPath(p))
+            excluded.push(p);
+        else
+            committable.push(p);
+    }
+    return { committable, excluded, unmerged };
+}
+export async function gitAddPaths(cwd, paths) {
+    if (paths.length === 0)
+        return;
+    const chunkSize = 80;
+    for (let i = 0; i < paths.length; i += chunkSize) {
+        const slice = paths.slice(i, i + chunkSize);
+        await runGit(cwd, ["add", "--", ...slice]);
+    }
+}
 /**
  * When the index/worktree is dirty, classify whether every changed path is
- * limited to governance docs (TASK files, project docs, logs, task state JSON).
- * Used by `vibeops task start` so `task done --finalize` on main does not
+ * limited to governance docs and VibeOps metadata (`.vibeops/**`, docs/tasks, etc.).
+ * Used when switching task branches so governance paths are not left off-disk after switch.
  * block the next TASK unless application code is also dirty.
  */
 export async function gitGovernanceOnlyDirty(cwd) {

package/dist/lib/llm-complete.js

@@ -0,0 +1,62 @@
+import { probeCodexOAuthFile } from "./plan-codex-auth.js";
+import { codexOAuthTextCompletion } from "./plan-codex-responses.js";
+import { cursorAgentPrint, extractAgentAssistantText } from "./plan-llm-cursor-agent.js";
+import { probeCursorAgentCli, probeOpenAiApiKey } from "./plan-llm-detect.js";
+import { extractJsonObject, openAiChatCompletionJson, openAiChatCompletionText, } from "./plan-llm-openai.js";
+/** Non-interactive: Codex OAuth → Cursor Agent → OpenAI API key (same sources as `vibeops plan`). */
+export async function resolveAvailableLlmProvider(cwd) {
+    const codex = await probeCodexOAuthFile();
+    if (codex.ok)
+        return "codex-oauth";
+    const cursor = await probeCursorAgentCli(cwd);
+    if (cursor.ok)
+        return "cursor-agent";
+    const openai = await probeOpenAiApiKey();
+    if (openai.ok)
+        return "openai";
+    return null;
+}
+function formatMessagesForCursor(messages) {
+    return messages
+        .map((m) => `### ${m.role}\n\n${m.content}`)
+        .join("\n\n---\n\n");
+}
+export async function llmCompleteText(messages, opts) {
+    const provider = opts.provider ?? (await resolveAvailableLlmProvider(opts.cwd));
+    if (provider === null) {
+        throw new Error("No LLM provider available. Use Codex OAuth (~/.codex/auth.json), Cursor Agent CLI (`agent login`), or OPENAI_API_KEY.");
+    }
+    if (provider === "openai") {
+        const text = await openAiChatCompletionText({ messages, model: opts.model });
+        return { text, provider };
+    }
+    if (provider === "codex-oauth") {
+        const text = await codexOAuthTextCompletion(messages, { model: opts.model });
+        return { text, provider };
+    }
+    const raw = await cursorAgentPrint({
+        cwd: opts.cwd,
+        prompt: formatMessagesForCursor(messages),
+        model: opts.model,
+    });
+    return { text: extractAgentAssistantText(raw), provider: "cursor-agent" };
+}
+export async function llmCompleteJson(messages, opts) {
+    const provider = opts.provider ?? (await resolveAvailableLlmProvider(opts.cwd));
+    if (provider === null) {
+        throw new Error("No LLM provider available. Use Codex OAuth (~/.codex/auth.json), Cursor Agent CLI (`agent login`), or OPENAI_API_KEY.");
+    }
+    if (provider === "openai") {
+        const text = await openAiChatCompletionJson({ messages, model: opts.model });
+        return { text, provider };
+    }
+    const jsonMessages = [
+        ...messages,
+        {
+            role: "user",
+            content: "Reply with a single JSON object only. No markdown code fences or extra prose.",
+        },
+    ];
+    const { text: raw } = await llmCompleteText(jsonMessages, { ...opts, provider });
+    return { text: extractJsonObject(raw), provider };
+}