@goodtek/vibeops 1.0.0 → 1.1.2

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-start.js

@@ -1,15 +1,17 @@
 import { relative, resolve } from "node:path";
 import { branchNameForTaskFile, readGitContext, readTaskFile, updateInlineStatus, upsertGitContext, } from "./task.js";
-import { detectDefaultBranch, gitBranchExists, gitCheckout, gitCheckoutNewBranch, gitGovernanceOnlyDirty, gitHeadCommit, readGitInfo, } from "./git.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 and mark TASK In Progress (used by `task add`). */
+/** 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) {
@@ -17,7 +19,7 @@ export async function startTaskBranch(opts) {
             log.info(dim("dry-run — would require a git repository"));
             return true;
         }
-        log.error("Not a git repository. Run `vibeops init --git` first.");
+        log.error("Not a git repository. Run `vibeops init` with Git setup first.");
         return false;
     }
     if (git.dirty === true && opts.allowDirty !== true) {
@@ -28,29 +30,55 @@ export async function startTaskBranch(opts) {
         }
         log.warn("Only governance paths are dirty — proceeding.");
     }
-    const baseBranch = git.branch ?? (await detectDefaultBranch(cwd)) ?? "main";
-    const baseCommit = (await gitHeadCommit(cwd)) ?? "";
-    if (baseCommit.length === 0) {
-        log.error("No commits on HEAD yet. Create an initial commit first.");
-        return false;
-    }
     const taskBranch = branchNameForTaskFile(taskFile);
-    const ctx = {
-        baseBranch,
-        baseCommit,
-        taskBranch,
-        startedAt: new Date().toISOString(),
-    };
     const existingCtx = await readGitContext(taskFile);
     const branchExists = await gitBranchExists(cwd, taskBranch);
-    log.info(`  ${dim("task branch")}  ${cyan(taskBranch)}`);
-    log.info(`  ${dim("base")}         ${baseBranch} @ ${baseCommit.slice(0, 7)}`);
     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 git switch -c ${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") {

package/dist/lib/task.js

@@ -353,6 +353,12 @@ function renderGitContextBlock(ctx) {
     if (typeof ctx.doneAt === "string" && ctx.doneAt.length > 0) {
         lines.push(`- Done At: \`${ctx.doneAt}\``);
     }
+    if (typeof ctx.mergeRequestUrl === "string" && ctx.mergeRequestUrl.length > 0) {
+        lines.push(`- Merge Request: ${ctx.mergeRequestUrl}`);
+    }
+    if (typeof ctx.pushedAt === "string" && ctx.pushedAt.length > 0) {
+        lines.push(`- Pushed At: \`${ctx.pushedAt}\``);
+    }
     return lines.join("\n");
 }
 export async function upsertGitContext(filePath, ctx) {
@@ -381,6 +387,8 @@ const GIT_CTX_RE = {
     taskBranch: /^-\s+Task Branch:\s*`([^`]+)`/m,
     startedAt: /^-\s+Started At:\s*`([^`]+)`/m,
     doneAt: /^-\s+Done At:\s*`([^`]+)`/m,
+    mergeRequestUrl: /^-\s+Merge Request:\s*(.+)$/m,
+    pushedAt: /^-\s+Pushed At:\s*`([^`]+)`/m,
 };
 export async function markGitContextDone(filePath) {
     const ctx = await readGitContext(filePath);
@@ -400,8 +408,15 @@ export async function readGitContext(filePath) {
     if (!baseBranch || !baseCommit || !taskBranch || !startedAt)
         return null;
     const doneAt = content.match(GIT_CTX_RE.doneAt)?.[1];
+    const mergeRequestUrl = content.match(GIT_CTX_RE.mergeRequestUrl)?.[1]?.trim();
+    const pushedAt = content.match(GIT_CTX_RE.pushedAt)?.[1];
     const ctx = { baseBranch, baseCommit, taskBranch, startedAt };
     if (typeof doneAt === "string" && doneAt.length > 0)
         ctx.doneAt = doneAt;
+    if (typeof mergeRequestUrl === "string" && mergeRequestUrl.length > 0) {
+        ctx.mergeRequestUrl = mergeRequestUrl;
+    }
+    if (typeof pushedAt === "string" && pushedAt.length > 0)
+        ctx.pushedAt = pushedAt;
     return ctx;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodtek/vibeops",
-  "version": "1.0.0",
+  "version": "1.1.2",
   "description": "Minimal CLI rails for Cursor-based TASK-driven vibe coding.",
   "type": "module",
   "author": "VibeOps contributors",

package/templates/clients/claude/CLAUDE.md

@@ -0,0 +1,28 @@
+# {{PROJECT_NAME}} — Claude Code
+
+Read **`AGENTS.md`** first (VibeOps workflow and source of truth).
+
+## Skills (project)
+
+| Skill | When |
+|-------|------|
+| `/plan-task` | Refine `docs/tasks/TASK-NNN-*.md` before coding |
+| `/implement-task` | Build per TASK Scope and Acceptance Criteria |
+
+Skills live in `.claude/skills/`.
+
+## Session start
+
+1. `docs/project/05-current-state.md`
+2. The **full** current `docs/tasks/TASK-NNN-*.md` file
+3. `docs/project/03-architecture.md` and `06-decisions.md` when relevant
+
+## Git
+
+- Branch: `task/*` from `vibeops task add`
+- Commit messages include the TASK id, e.g. `feat(task-015): short title`
+- Do not merge to main unless the human runs `vibeops task done` or asks
+
+## Finishing
+
+Fill **Result** and **Test Result** in the TASK file, then tell the human to run `vibeops task done TASK-NNN`.

package/templates/{AGENTS.md → core/AGENTS.md}

@@ -1,6 +1,6 @@
 # {{PROJECT_NAME}} — AI agent guide
 
-> Installed by **VibeOps**. Cursor reads this repo, not chat history.
+> Installed by **VibeOps**. Agents read this repo and `docs/tasks/`, not chat history.
 
 ## Source of truth
 
@@ -9,7 +9,7 @@
 | Current work | `docs/tasks/TASK-NNN-*.md` |
 | Project memory | `docs/project/05-current-state.md`, `03-architecture.md`, `06-decisions.md` |
 | Change history | Git commits on task branches |
-| **Not** trusted | Cursor chat, Slack |
+| **Not** trusted | Chat history, Slack |
 
 ## Before you code
 
@@ -20,18 +20,25 @@
 ## Workflow (human + CLI)
 
 ```bash
-vibeops init              # once
+vibeops init              # once (pick Cursor / Claude Code / Codex packs)
 vibeops task add          # new TASK + branch
-# Plan in Cursor Ask: @docs/tasks/TASK-NNN-….md
-# Build in Cursor Agent: same file + Scope / Acceptance Criteria
+# Plan: refine TASK file with your agent (see client skills below)
+# Build: implement per TASK Scope / Acceptance Criteria
 vibeops task done         # close TASK, update project docs, merge
 vibeops status            # briefing
+vibeops llm connect       # LLM for task add / task done
 ```
 
-## Rules
+## Client packs (installed at init)
+
+| Tool | Rules / guide | Skills |
+|------|----------------|--------|
+| **Cursor** | `.cursor/rules/` | `.cursor/skills/` (`plan-task`, `implement-task`) |
+| **Claude Code** | `CLAUDE.md` | `.claude/skills/` |
+| **Codex CLI** | `AGENTS.md` (this file) | `.agents/skills/` |
+
+## Rules (all agents)
 
 - **One TASK at a time** — stay inside Scope and Acceptance Criteria.
 - **Search** before adding files; reuse existing patterns.
-- When the TASK is finished, **Result** and **Test Result** must be filled before `vibeops task done`.
-
-Details: `.cursor/rules/`.
+- Fill **Result** and **Test Result** before `vibeops task done`.

package/templates/{.cursor/skills → skills-shared}/implement-task/SKILL.md

@@ -8,7 +8,7 @@ disable-model-invocation: true
 
 ## Read first
 
-1. `AGENTS.md` and `.cursor/rules/`
+1. `AGENTS.md` and your agent rules (e.g. `.cursor/rules/`, `CLAUDE.md`)
 2. `docs/project/05-current-state.md`, `03-architecture.md`, `06-decisions.md`
 3. The TASK file referenced by the human
 

package/templates/{.cursor/skills → skills-shared}/plan-task/SKILL.md

@@ -6,14 +6,14 @@ disable-model-invocation: true
 
 # Plan a TASK
 
-The human opened a TASK file (e.g. `@docs/tasks/TASK-015-….md`).
+The human opened a TASK file (e.g. `docs/tasks/TASK-015-….md`).
 
 ## Instructions
 
-1. Read the TASK file and `docs/project/05-current-state.md`.
+1. Read `AGENTS.md`, your agent rules, and the TASK file; read `docs/project/05-current-state.md`.
 2. Ask only what is missing to make **Scope**, **Acceptance Criteria**, and **Test Plan** verifiable.
 3. Edit the TASK file in place — do not create a second TASK id.
 4. Keep **Out of Scope** explicit.
 5. Do not write application code in this step unless the human asks.
 
-When planning is enough, tell the human to switch to Agent mode and implement per the TASK.
+When planning is enough, tell the human to implement per the TASK (Agent mode / Codex / Claude Code as they prefer).

package/dist/lib/task-merge.js

@@ -1,115 +0,0 @@
-import { gitBranchExists, gitCheckout, gitDeleteBranch, gitGovernanceOnlyDirty, gitRemoteUrl, readGitInfo, runGit, } from "./git.js";
-import { bold, cyan, dim, log } from "./logger.js";
-function mergeCommitMessage(taskId, taskTitle, taskBranch) {
-    const slug = taskTitle.replace(/^TASK-\d+\s*[:\-]\s*/i, "").trim() || taskId;
-    return `merge(${taskId.toLowerCase()}): ${slug} (${taskBranch})`;
-}
-async function gitPush(cwd, remote, ref, setUpstream) {
-    const args = ["push"];
-    if (setUpstream)
-        args.push("-u");
-    args.push(remote, ref);
-    await runGit(cwd, args);
-}
-export async function mergeTaskBranch(opts) {
-    const remote = opts.remote ?? "origin";
-    const { cwd, gitCtx, taskId, taskTitle } = opts;
-    const { baseBranch, taskBranch } = gitCtx;
-    if (baseBranch === taskBranch) {
-        log.error("Task branch matches base branch; nothing to merge.");
-        return { ok: false };
-    }
-    const git = await readGitInfo(cwd);
-    if (!git.isRepo) {
-        log.error("Not a git repository.");
-        return { ok: false };
-    }
-    const branchExists = await gitBranchExists(cwd, taskBranch);
-    if (!branchExists) {
-        log.error(`Local task branch not found: ${taskBranch}`);
-        return { ok: false };
-    }
-    const remoteUrl = await gitRemoteUrl(cwd, remote);
-    const hasRemote = remoteUrl !== null;
-    if (opts.dryRun) {
-        log.info(bold("dry-run — would merge:"));
-        log.info(`  · checkout ${baseBranch}`);
-        log.info(`  · merge --no-ff ${taskBranch}`);
-        if (hasRemote)
-            log.info(`  · push ${remote} (optional)`);
-        log.info(`  · delete local ${taskBranch}`);
-        return { ok: true };
-    }
-    if (git.dirty === true && opts.allowDirty !== true) {
-        const gov = await gitGovernanceOnlyDirty(cwd);
-        if (!gov.onlyGovernance) {
-            log.error("Working tree is dirty. Commit or use --allow-dirty.");
-            return { ok: false };
-        }
-        log.warn("Dirty tree is governance-only — proceeding.");
-    }
-    log.step(bold(`Merging ${cyan(taskBranch)} → ${cyan(baseBranch)}`));
-    try {
-        if (hasRemote) {
-            try {
-                await gitPush(cwd, remote, taskBranch, true);
-                await runGit(cwd, ["fetch", remote]);
-            }
-            catch (e) {
-                const msg = e instanceof Error ? e.message : String(e);
-                log.warn(`Push skipped (${msg}). Continuing with local merge.`);
-            }
-        }
-        await gitCheckout(cwd, baseBranch);
-        if (hasRemote) {
-            try {
-                await runGit(cwd, ["pull", remote, baseBranch]);
-            }
-            catch {
-                log.warn(dim(`Could not pull ${remote}/${baseBranch} — merging locally.`));
-            }
-        }
-        await runGit(cwd, [
-            "merge",
-            "--no-ff",
-            taskBranch,
-            "-m",
-            mergeCommitMessage(taskId, taskTitle, taskBranch),
-        ]);
-        if (hasRemote) {
-            try {
-                await gitPush(cwd, remote, baseBranch, false);
-            }
-            catch {
-                log.warn(dim(`Merge commit created locally; push ${remote} ${baseBranch} manually.`));
-            }
-        }
-        log.ok(`Merged into ${baseBranch}`);
-    }
-    catch (e) {
-        const msg = e instanceof Error ? e.message : String(e);
-        log.error(`Merge failed: ${msg}`);
-        return { ok: false };
-    }
-    try {
-        await gitDeleteBranch(cwd, taskBranch, { force: false });
-        log.ok(`Deleted local branch ${taskBranch}`);
-    }
-    catch {
-        try {
-            await gitDeleteBranch(cwd, taskBranch, { force: true });
-        }
-        catch {
-            log.warn(`Could not delete local branch ${taskBranch}.`);
-        }
-    }
-    if (hasRemote) {
-        try {
-            await runGit(cwd, ["push", remote, "--delete", taskBranch]);
-        }
-        catch {
-            log.warn(dim(`Remote branch ${remote}/${taskBranch} may already be gone.`));
-        }
-    }
-    return { ok: true };
-}