@goodtek/vibeops 0.7.22 → 1.1.1

package/dist/commands/task-done.js

@@ -1,98 +1,137 @@
-import { relative, resolve } from "node:path";
+import { resolve } from "node:path";
 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 { 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";
+import { finishTaskWithPullRequest } from "../lib/task-push-pr.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 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("  · commit if dirty, push task branch, open MR/PR (unless --no-pr)");
+        log.info("  · Status → Done after push/MR succeed");
+        await finishTaskWithPullRequest({
+            cwd,
+            taskFile,
+            dryRun: true,
+            skipPr: options.noPr === true,
+        });
+        return;
     }
-    const ctx = await readGitContext(taskFile);
     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}\``)}`);
+    const commitMsg = commitMessageFor(parts.id, meta.title);
+    await tryCommitDirty(cwd, commitMsg, false);
+    const gitCtx = await readGitContext(taskFile);
+    if (gitCtx !== null) {
+        const prResult = await finishTaskWithPullRequest({
+            cwd,
+            taskFile,
+            skipPr: options.noPr === true,
+        });
+        if (!prResult.ok) {
+            log.error("TASK left In Progress — fix push/MR, then rerun task done.");
+            process.exitCode = 1;
+            return;
+        }
+        if (prResult.mergeRequestUrl) {
+            log.info(`  ${dim("MR/PR")}     ${prResult.mergeRequestUrl}`);
+            log.info(dim("Merge on GitHub/GitLab — CI deploys after merge."));
+        }
     }
     else {
-        log.info(`  ${dim("(no Git Context section — skipping merge guidance)")}`);
+        log.info(dim("No Git Context — push/MR skipped."));
     }
+    await updateInlineStatus(taskFile, "done");
+    await markGitContextDone(taskFile);
+    log.ok("Status → Done");
     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)")}`);
-    }
-    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

@@ -1,39 +1,56 @@
 import { join } from "node:path";
-import { readTextOrNull, writeText } from "./filesystem.js";
+import { pathExists, 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")
+import { VIBEOPS_CONFIG_SCHEMA_VERSION, } from "../types/config.js";
+import { isVibeopsClientId } from "./init-clients.js";
+function parseClientsBlock(raw) {
+    if (!Array.isArray(raw))
         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;
+    const out = [];
+    for (const item of raw) {
+        if (typeof item === "string" && isVibeopsClientId(item) && !out.includes(item)) {
+            out.push(item);
+        }
+    }
+    return out.length > 0 ? out : undefined;
 }
-function parseGithubVisibility(raw) {
-    if (raw === "public" || raw === "private")
-        return raw;
-    return "";
+export function getClientsFromConfig(config) {
+    if (config?.clients && config.clients.length > 0)
+        return [...config.clients];
+    return ["cursor"];
 }
-function parseGithubSection(raw) {
-    if (raw === null || typeof raw !== "object")
+export async function isVibeopsProject(root) {
+    if ((await readConfig(root)) !== null)
+        return true;
+    return pathExists(join(root, VIBEOPS_CONFIG_FILE));
+}
+function parseGitBlock(raw) {
+    if (raw === null || raw === undefined || typeof raw !== "object" || Array.isArray(raw)) {
         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 : "",
-    };
+    }
+    const o = raw;
+    const remote = typeof o.remote === "string" && o.remote.length > 0 ? o.remote : "origin";
+    const host = o.host === "github" || o.host === "gitlab" ? o.host : undefined;
+    const integrationBranch = typeof o.integrationBranch === "string" && o.integrationBranch.length > 0
+        ? o.integrationBranch
+        : undefined;
+    const productionBranch = typeof o.productionBranch === "string" && o.productionBranch.length > 0
+        ? o.productionBranch
+        : undefined;
+    if (!host || !integrationBranch || !productionBranch)
+        return undefined;
+    return { remote, host, integrationBranch, productionBranch };
+}
+function parseLlmBlock(raw) {
+    if (raw === null || raw === undefined || typeof raw !== "object" || Array.isArray(raw)) {
+        return undefined;
+    }
+    const p = raw.provider;
+    if (p === "auto" || p === "codex-oauth" || p === "cursor-agent" || p === "openai") {
+        return { provider: p };
+    }
+    return undefined;
 }
 export async function readConfig(root) {
     const text = await readTextOrNull(join(root, VIBEOPS_CONFIG_FILE));
@@ -45,19 +62,18 @@ 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 = {
+            const llm = parseLlmBlock(parsed.llm);
+            const git = parseGitBlock(parsed.git);
+            const clients = parseClientsBlock(parsed.clients) ?? ["cursor"];
+            return {
                 name: parsed.name,
                 vibeopsVersion: parsed.vibeopsVersion,
                 schemaVersion: VIBEOPS_CONFIG_SCHEMA_VERSION,
                 createdAt: parsed.createdAt,
+                clients,
+                ...(git ? { git } : {}),
+                ...(llm ? { llm } : {}),
             };
-            if (notion)
-                config.notion = notion;
-            if (github)
-                config.github = github;
-            return config;
         }
         return null;
     }
@@ -65,12 +81,15 @@ export async function readConfig(root) {
         return null;
     }
 }
-export function buildConfig(name, nowIso) {
+export function buildConfig(name, clients, git, existing, nowIso) {
     return {
         name,
         vibeopsVersion: VERSION,
         schemaVersion: VIBEOPS_CONFIG_SCHEMA_VERSION,
-        createdAt: nowIso ?? new Date().toISOString(),
+        createdAt: existing?.createdAt ?? nowIso ?? new Date().toISOString(),
+        clients,
+        git,
+        llm: existing?.llm ?? { provider: "auto" },
     };
 }
 export function configToJson(config) {
@@ -79,80 +98,25 @@ 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).
+ * Merge `llm.provider` into existing `.vibeops.json` (preserves other keys).
  */
-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 };
+export async function setLlmProviderPreference(root, provider) {
+    const path = join(root, VIBEOPS_CONFIG_FILE);
+    const text = await readTextOrNull(path);
+    if (text === null) {
+        throw new Error(`${VIBEOPS_CONFIG_FILE} not found — run vibeops init first.`);
+    }
+    let data;
+    try {
+        data = JSON.parse(text);
+    }
+    catch {
+        throw new Error(`${VIBEOPS_CONFIG_FILE} is not valid JSON.`);
+    }
+    const prevLlm = typeof data.llm === "object" && data.llm !== null && !Array.isArray(data.llm)
+        ? data.llm
+        : {};
+    data.llm = { ...prevLlm, provider };
+    await writeText(path, `${JSON.stringify(data, null, 2)}\n`);
 }

package/dist/lib/env.js

@@ -0,0 +1,32 @@
+import { readFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { VIBEOPS_ENV_FILE } from "./paths.js";
+/**
+ * Loads `KEY=value` pairs from `.vibeops.env` without overwriting existing `process.env`.
+ */
+export async function loadVibeopsEnv(cwd) {
+    const path = join(resolve(cwd), VIBEOPS_ENV_FILE);
+    try {
+        const text = await readFile(path, "utf-8");
+        for (const line of text.split("\n")) {
+            const t = line.trim();
+            if (t.length === 0 || t.startsWith("#"))
+                continue;
+            const eq = t.indexOf("=");
+            if (eq <= 0)
+                continue;
+            const key = t.slice(0, eq).trim();
+            let val = t.slice(eq + 1).trim();
+            if ((val.startsWith('"') && val.endsWith('"')) ||
+                (val.startsWith("'") && val.endsWith("'"))) {
+                val = val.slice(1, -1);
+            }
+            if (key.length > 0 && process.env[key] === undefined) {
+                process.env[key] = val;
+            }
+        }
+    }
+    catch {
+        /* missing or unreadable — ok */
+    }
+}

package/dist/lib/git-config.js

@@ -0,0 +1,21 @@
+import { readConfig } from "./config.js";
+export class GitConfigError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "GitConfigError";
+    }
+}
+/** Load `.vibeops.json` git block or throw with re-init guidance. */
+export async function requireGitConfig(cwd) {
+    const config = await readConfig(cwd);
+    if (!config) {
+        throw new GitConfigError("No .vibeops.json found. Run vibeops init in this project first.");
+    }
+    if (!config.git?.integrationBranch || !config.git?.productionBranch) {
+        throw new GitConfigError("Missing git policy in .vibeops.json. Re-run vibeops init to set integration and production branches.");
+    }
+    if (!config.git.host || !config.git.remote) {
+        throw new GitConfigError("Incomplete git config in .vibeops.json. Re-run vibeops init.");
+    }
+    return config.git;
+}

package/dist/lib/git-host.js

@@ -0,0 +1,12 @@
+/** Infer Git host from a remote URL. */
+export function detectGitHost(remoteUrl) {
+    const u = remoteUrl.trim().toLowerCase();
+    if (u.includes("github.com"))
+        return "github";
+    if (u.includes("gitlab"))
+        return "gitlab";
+    return null;
+}
+export function mergeRequestLabel(host) {
+    return host === "gitlab" ? "Merge request" : "Pull request";
+}

package/dist/lib/git-policy.js

@@ -0,0 +1,67 @@
+import { select } from "@inquirer/prompts";
+import { askInput } from "./inquirer-helpers.js";
+export const GIT_POLICY_PRESETS = [
+    {
+        id: "gitflow",
+        label: "GitFlow lite — develop (integration) + main (production)",
+        integrationBranch: "develop",
+        productionBranch: "main",
+    },
+    {
+        id: "trunk",
+        label: "Trunk — main only (integration and production = main)",
+        integrationBranch: "main",
+        productionBranch: "main",
+    },
+];
+export function parseGitPolicyArg(raw) {
+    if (raw === undefined || raw.trim().length === 0)
+        return null;
+    const t = raw.trim().toLowerCase();
+    if (t === "gitflow" || t === "develop-main")
+        return "gitflow";
+    if (t === "trunk" || t === "main")
+        return "trunk";
+    if (t === "custom")
+        return "custom";
+    return null;
+}
+export function resolvePreset(id) {
+    return GIT_POLICY_PRESETS.find((p) => p.id === id) ?? null;
+}
+export async function askGitPolicy() {
+    const preset = await select({
+        message: "Branch policy",
+        choices: [
+            ...GIT_POLICY_PRESETS.map((p) => ({ name: p.label, value: p.id })),
+            { name: "Custom branch names", value: "custom" },
+        ],
+        loop: false,
+    });
+    if (preset !== "custom") {
+        const p = resolvePreset(preset);
+        return {
+            integrationBranch: p.integrationBranch,
+            productionBranch: p.productionBranch,
+        };
+    }
+    const integrationBranch = await askInput({
+        message: "Integration branch (task branches start here; MR/PR target)",
+        nonInteractive: false,
+        default: "develop",
+        required: true,
+    });
+    const productionBranch = await askInput({
+        message: "Production branch (releases / deploy; merge manually)",
+        nonInteractive: false,
+        default: "main",
+        required: true,
+    });
+    return { integrationBranch, productionBranch };
+}
+export function formatGitPolicySummary(git) {
+    if (git.integrationBranch === git.productionBranch) {
+        return `${git.integrationBranch} (integration + production)`;
+    }
+    return `integration=${git.integrationBranch}, production=${git.productionBranch}`;
+}