ai-foreman 1.3.0 → 1.4.0

package/dist/branch/runner.js

@@ -1,11 +1,15 @@
 import { Foreman, MARKER_SPEC } from "../foreman.js";
 import { fireNotification } from "../notify.js";
 import { cmdBlock, cmdComplete, cmdUpdate } from "../tickets/commands.js";
-import { commitAll, createTicketWorktree, currentWorktreeBranch, ensureCleanBaseWorktree, ensureForemanExcluded, hasTrackerChanges, hasWorktreeChanges, headCommitIfAhead, removeTicketWorktree, } from "./git.js";
-import { createOrReusePr, pushBranchForPr } from "./github.js";
+import { commitAll, createTicketWorktree, currentWorktreeBranch, deleteLocalBranch, ensureCleanBaseWorktree, ensureForemanExcluded, hasTrackerChanges, hasWorktreeChanges, headCommitIfAhead, removeTicketWorktree, squashMergeBranchToLocalBase, } from "./git.js";
+import { checkGitHubPrMerged, createOrReusePr, enableGitHubAutoMerge, pushBranchForPr } from "./github.js";
+import { checkGitLabMrMerged, createOrReuseMr, enableGitLabAutoMerge, pushBranchForMr } from "./gitlab.js";
 export async function runBranchPlan(opts) {
     ensureCleanBaseWorktree(opts.projectDir, { allowedDirtyPaths: opts.allowedBaseDirtyPaths });
     ensureForemanExcluded(opts.projectDir);
+    const completionMode = opts.completionMode ?? (opts.createPr ? "pr" : "none");
+    const reviewProvider = opts.reviewProvider ?? "github";
+    const createsReview = completionMode === "pr" || completionMode === "auto-merge";
     const summaries = [];
     const successfulBranches = new Set();
     const pushedBranches = new Set();
@@ -38,7 +42,7 @@ export async function runBranchPlan(opts) {
             notifyIssue(opts.notificationsEnabled, detail);
             continue;
         }
-        if (opts.createPr) {
+        if (createsReview) {
             const missingPush = node.dependencies.find((dep) => {
                 const depNode = opts.plan.nodes.find((candidate) => candidate.ticket.id === dep);
                 return depNode && !pushedBranches.has(depNode.branch);
@@ -56,6 +60,23 @@ export async function runBranchPlan(opts) {
                 continue;
             }
         }
+        if (completionMode === "auto-merge" && node.dependencies.length > 0) {
+            const mergeReadiness = await waitForAutoMergeDependencies(opts, node, reviewProvider);
+            if (!mergeReadiness.ok) {
+                summaries.push(summaryFor(node, "skipped", mergeReadiness.message, "skipped"));
+                opts.log.write("branch-issue", {
+                    ticket: node.ticket.id,
+                    code: mergeReadiness.code,
+                    message: mergeReadiness.message,
+                    blocking: false,
+                    repairCommands: mergeReadiness.repairCommands,
+                    command: mergeReadiness.command,
+                    output: mergeReadiness.output,
+                });
+                notifyIssue(opts.notificationsEnabled, `${node.ticket.id}: ${mergeReadiness.message}`);
+                continue;
+            }
+        }
         opts.log.write("branch-start", {
             ticket: node.ticket.id,
             branch: node.branch,
@@ -100,7 +121,9 @@ export async function runBranchPlan(opts) {
                     effort: opts.effort,
                     fast: opts.fast,
                     qaEnabled: opts.qaEnabled,
-                    createPr: opts.createPr,
+                    createPr: createsReview,
+                    completionMode,
+                    reviewProvider,
                     prReady: opts.prReady,
                     keepWorktrees: opts.keepWorktrees,
                 });
@@ -157,13 +180,15 @@ export async function runBranchPlan(opts) {
             if (hasWorktreeChanges(worktreePath)) {
                 commit = commitAll(worktreePath, `${node.ticket.id}: ${node.ticket.title}`);
             }
-            if (!commit && opts.createPr) {
+            if (!commit && (createsReview || completionMode === "direct-merge")) {
                 commit = headCommitIfAhead(worktreePath, node.baseBranch);
             }
             const summary = summaryFor(node, "done", commit ? undefined : "no_changes");
             summary.commit = commit;
-            if (commit && opts.createPr) {
-                const push = pushBranchForPr(worktreePath, node.branch);
+            if (commit && createsReview) {
+                const push = reviewProvider === "gitlab"
+                    ? pushBranchForMr(worktreePath, node.branch)
+                    : pushBranchForPr(worktreePath, node.branch);
                 if (push.ok) {
                     opts.log.write("branch-push", { ticket: node.ticket.id, branch: node.branch, status: "pushed" });
                     summary.pushStatus = "pushed";
@@ -194,29 +219,75 @@ export async function runBranchPlan(opts) {
                     continue;
                 }
                 pushedBranches.add(node.branch);
-                const pr = createOrReusePr(opts.projectDir, {
-                    node,
-                    ready: opts.prReady,
-                    runId: opts.runId,
-                    qaEvidence: qaSummary,
-                    commit,
-                });
+                const pr = reviewProvider === "gitlab"
+                    ? createOrReuseMr(opts.projectDir, {
+                        node,
+                        ready: opts.prReady || completionMode === "auto-merge",
+                        runId: opts.runId,
+                        qaEvidence: qaSummary,
+                        commit,
+                        autoMerge: completionMode === "auto-merge",
+                        cleanup: opts.cleanupBranches ?? true,
+                    })
+                    : createOrReusePr(opts.projectDir, {
+                        node,
+                        ready: opts.prReady || completionMode === "auto-merge",
+                        runId: opts.runId,
+                        qaEvidence: qaSummary,
+                        commit,
+                    });
                 summary.pr = pr;
                 if (pr.status === "created")
-                    opts.log.write("pr-created", { ticket: node.ticket.id, branch: node.branch, url: pr.url });
+                    opts.log.write(reviewProvider === "gitlab" ? "mr-created" : "pr-created", { ticket: node.ticket.id, branch: node.branch, url: pr.url });
                 if (pr.status === "existing")
-                    opts.log.write("pr-existing", { ticket: node.ticket.id, branch: node.branch, url: pr.url });
+                    opts.log.write(reviewProvider === "gitlab" ? "mr-existing" : "pr-existing", { ticket: node.ticket.id, branch: node.branch, url: pr.url });
                 if (pr.status === "failed") {
-                    opts.log.write("pr-failed", failureLogFields(node, pr));
-                    blockBranchIssue(opts, node, summary, pr.code ?? "pr_create_failed", `PR creation failed: ${pr.message ?? pr.error ?? "unknown error"}`, pr);
+                    opts.log.write(reviewProvider === "gitlab" ? "mr-failed" : "pr-failed", failureLogFields(node, pr));
+                    blockBranchIssue(opts, node, summary, pr.code ?? (reviewProvider === "gitlab" ? "mr_create_failed" : "pr_create_failed"), `${reviewProvider === "gitlab" ? "MR" : "PR"} creation failed: ${pr.message ?? pr.error ?? "unknown error"}`, pr);
                     summaries.push(summary);
                     continue;
                 }
+                if (completionMode === "auto-merge" && reviewProvider === "github") {
+                    const autoMerge = enableGitHubAutoMerge(opts.projectDir, node.branch, opts.cleanupBranches ?? true);
+                    summary.pr = autoMerge.status === "failed" ? autoMerge : { ...pr, status: "auto_merge_enabled", url: autoMerge.url ?? pr.url };
+                    if (autoMerge.status === "failed") {
+                        opts.log.write("pr-auto-merge-failed", failureLogFields(node, autoMerge));
+                        blockBranchIssue(opts, node, summary, autoMerge.code ?? "pr_create_failed", `PR auto-merge failed: ${autoMerge.message ?? autoMerge.error ?? "unknown error"}`, autoMerge);
+                        summaries.push(summary);
+                        continue;
+                    }
+                    opts.log.write("pr-auto-merge-enabled", { ticket: node.ticket.id, branch: node.branch, url: summary.pr.url });
+                }
+                else if (completionMode === "auto-merge" && reviewProvider === "gitlab" && pr.status === "existing") {
+                    const autoMerge = enableGitLabAutoMerge(opts.projectDir, node.branch, opts.cleanupBranches ?? true);
+                    summary.pr = autoMerge.status === "failed" ? autoMerge : { ...pr, status: "auto_merge_enabled", url: autoMerge.url ?? pr.url };
+                    if (autoMerge.status === "failed") {
+                        opts.log.write("mr-auto-merge-failed", failureLogFields(node, autoMerge));
+                        blockBranchIssue(opts, node, summary, autoMerge.code ?? "mr_create_failed", `MR auto-merge failed: ${autoMerge.message ?? autoMerge.error ?? "unknown error"}`, autoMerge);
+                        summaries.push(summary);
+                        continue;
+                    }
+                    opts.log.write("mr-auto-merge-enabled", { ticket: node.ticket.id, branch: node.branch, url: summary.pr.url });
+                }
             }
-            else if (opts.createPr) {
+            else if (createsReview) {
                 summary.pushStatus = "skipped";
                 summary.pr = { status: "skipped", error: commit ? undefined : "no_changes" };
             }
+            else if (commit && completionMode === "direct-merge") {
+                if (!opts.keepWorktrees)
+                    removeTicketWorktree(opts.projectDir, worktreePath);
+                const mergeCommit = squashMergeBranchToLocalBase(opts.projectDir, node.branch, node.baseBranch, `${node.ticket.id}: ${node.ticket.title}`);
+                summary.pr = { status: "merged", url: mergeCommit };
+                opts.log.write("branch-direct-merge", {
+                    ticket: node.ticket.id,
+                    branch: node.branch,
+                    base: node.baseBranch,
+                    commit: mergeCommit,
+                });
+                if (opts.cleanupBranches ?? true)
+                    deleteLocalBranch(opts.projectDir, node.branch);
+            }
             cmdComplete(opts.projectDir, node.ticket.id, {
                 actor: "foreman",
                 summary: status.summary ?? `Completed ${node.ticket.id}`,
@@ -233,7 +304,7 @@ export async function runBranchPlan(opts) {
                 status: "done",
                 detail: summary.detail,
             });
-            if (!opts.keepWorktrees)
+            if (!opts.keepWorktrees && completionMode !== "direct-merge")
                 removeTicketWorktree(opts.projectDir, worktreePath);
         }
         catch (err) {
@@ -255,6 +326,70 @@ export async function runBranchPlan(opts) {
     }
     return summaries;
 }
+async function waitForAutoMergeDependencies(opts, node, provider) {
+    const dependencyNodes = node.dependencies
+        .map((dep) => opts.plan.nodes.find((candidate) => candidate.ticket.id === dep))
+        .filter((dep) => Boolean(dep));
+    if (dependencyNodes.length === 0)
+        return { ok: true };
+    const timeoutMs = opts.autoMergeTimeoutMinutes === null || opts.autoMergeTimeoutMinutes === undefined
+        ? null
+        : opts.autoMergeTimeoutMinutes * 60_000;
+    const deadline = opts.autoMergeWait && timeoutMs !== null ? Date.now() + timeoutMs : null;
+    while (true) {
+        const pending = [];
+        for (const dep of dependencyNodes) {
+            const status = provider === "gitlab"
+                ? checkGitLabMrMerged(opts.projectDir, dep.branch)
+                : checkGitHubPrMerged(opts.projectDir, dep.branch);
+            if (!status.ok) {
+                return {
+                    ok: false,
+                    code: status.code,
+                    message: `dependency ${dep.ticket.id} merge check failed: ${status.message}`,
+                    repairCommands: status.repairCommands,
+                    command: status.command,
+                    output: status.output,
+                };
+            }
+            if (!status.merged)
+                pending.push(`${dep.ticket.id}${status.state ? ` (${status.state})` : ""}`);
+        }
+        if (pending.length === 0)
+            return { ok: true };
+        const message = `auto-merge dependency ${pending.join(", ")} has not merged into the root base yet`;
+        if (!opts.autoMergeWait) {
+            return {
+                ok: false,
+                code: "dependency_unavailable",
+                message: `${message}; rerun after it merges or enable auto-merge wait in ticket setup`,
+            };
+        }
+        if (deadline !== null && Date.now() >= deadline) {
+            return {
+                ok: false,
+                code: "dependency_unavailable",
+                message: `${message}; timed out waiting for dependency merge`,
+            };
+        }
+        opts.log.write("branch-auto-merge-wait", {
+            ticket: node.ticket.id,
+            pending,
+            timeoutMinutes: opts.autoMergeTimeoutMinutes ?? null,
+        });
+        await sleep(autoMergePollMs());
+    }
+}
+function autoMergePollMs() {
+    const raw = process.env.RAFI_AUTO_MERGE_POLL_MS;
+    if (!raw)
+        return 30_000;
+    const parsed = Number.parseInt(raw, 10);
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : 30_000;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
 function notifyIssue(enabled, message) {
     if (enabled)
         fireNotification("Foreman branch issue", message);

package/dist/branch/types.d.ts

@@ -14,7 +14,7 @@ export interface BranchIssue {
     message: string;
     blocking: boolean;
 }
-export type GitHubFailureCode = "gh_missing" | "gh_not_authenticated" | "remote_missing" | "remote_not_github" | "repo_unreachable" | "git_remote_unreachable" | "push_failed" | "pr_create_failed" | "network_or_timeout" | "unknown";
+export type GitHubFailureCode = "gh_missing" | "glab_missing" | "gh_not_authenticated" | "glab_not_authenticated" | "remote_missing" | "remote_not_github" | "remote_not_gitlab" | "repo_unreachable" | "git_remote_unreachable" | "push_failed" | "pr_create_failed" | "mr_create_failed" | "network_or_timeout" | "unknown";
 export interface GitHubFailure {
     ok: false;
     code: GitHubFailureCode;
@@ -43,13 +43,21 @@ export type GitHubOperationResult = {
     ok: true;
     output?: string;
 } | GitHubFailure;
+export type ReviewMergeStatus = {
+    ok: true;
+    merged: boolean;
+    state?: string;
+    url?: string;
+} | GitHubFailure;
 export interface BranchPlan {
     baseRef: string;
     nodes: BranchPlanNode[];
     issues: BranchIssue[];
 }
+export type CompletionMode = "none" | "pr" | "auto-merge" | "direct-merge";
+export type ReviewProvider = "github" | "gitlab";
 export interface PrResult {
-    status: "created" | "existing" | "failed" | "skipped";
+    status: "created" | "existing" | "failed" | "skipped" | "auto_merge_enabled" | "merged";
     url?: string;
     error?: string;
     code?: GitHubFailureCode;

package/dist/cli/start.js

@@ -18,8 +18,10 @@ import { StateDb } from "../tickets/stateDb.js";
 import { buildBranchAuditInstruction, buildBranchPlan, parseAuditDependencies } from "../branch/planner.js";
 import { currentGitRef, ensureCleanBaseWorktree, generatedTrackerDirtyPaths } from "../branch/git.js";
 import { formatGitHubFailure, preflightGh } from "../branch/github.js";
+import { preflightGlab } from "../branch/gitlab.js";
 import { runBranchPlan } from "../branch/runner.js";
 import { findResumableBranchSessions, formatBranchContinueCommand, formatBranchSummaryFollowupCommands, } from "../branch/resume.js";
+import { detectGitProvider, loadTicketSetupConfig } from "../tickets/setupConfig.js";
 function fail(message) {
     console.error(`foreman: ${message}`);
     process.exit(1);
@@ -47,6 +49,80 @@ function collectTicket(value, previous) {
 function unique(values) {
     return [...new Set(values)];
 }
+function optionWasProvided(command, name) {
+    const source = command.getOptionValueSource(name);
+    return source !== undefined && source !== "default";
+}
+function resolveStartBranchDefaults(cwd, opts, command) {
+    const setup = loadTicketSetupConfig(cwd);
+    const savedBuild = setup?.build;
+    const branchFlagProvided = optionWasProvided(command, "branchPerTicket");
+    const branchFlagOn = branchFlagProvided && opts.branchPerTicket !== false;
+    const createPrFlagProvided = optionWasProvided(command, "createPr");
+    const createPrFlagOn = createPrFlagProvided && opts.createPr !== false;
+    const completionFromFlag = typeof opts.completion === "string"
+        ? parseCompletionMode(opts.completion)
+        : undefined;
+    let completionMode = completionFromFlag
+        ?? (createPrFlagOn ? "pr" : undefined)
+        ?? savedBuild?.completion
+        ?? "none";
+    if (createPrFlagProvided && opts.createPr === false) {
+        completionMode = "none";
+    }
+    const savedBranchMode = savedBuild?.branch_strategy === "branch-per-ticket";
+    let branchMode = Boolean(savedBranchMode || branchFlagOn || createPrFlagOn || completionMode !== "none");
+    if (branchFlagProvided && opts.branchPerTicket === false) {
+        branchMode = false;
+        completionMode = "none";
+    }
+    if (completionMode !== "none")
+        branchMode = true;
+    const providerFromFlag = typeof opts.provider === "string" ? parseReviewProviderOption(opts.provider, cwd) : undefined;
+    const provider = providerFromFlag ?? (createPrFlagOn ? "github" : providerFromSaved(savedBuild?.provider, cwd));
+    const autoMergeWaitProvided = optionWasProvided(command, "autoMergeWait");
+    const autoMergeTimeoutMinutes = typeof opts.autoMergeTimeoutMinutes === "string"
+        ? parseOptionalPositiveInteger(opts.autoMergeTimeoutMinutes, "--auto-merge-timeout-minutes")
+        : savedBuild?.auto_merge_timeout_minutes ?? null;
+    return {
+        branchMode,
+        completionMode,
+        reviewProvider: provider,
+        createReview: completionMode === "pr" || completionMode === "auto-merge",
+        prReady: Boolean(opts.prReady || savedBuild?.pr_ready || completionMode === "auto-merge"),
+        cleanupBranches: opts.keepWorktrees ? false : savedBuild?.cleanup ?? true,
+        rootBaseBranches: completionMode === "auto-merge" || completionMode === "direct-merge",
+        autoMergeWait: autoMergeWaitProvided ? opts.autoMergeWait !== false : savedBuild?.auto_merge_wait ?? false,
+        autoMergeTimeoutMinutes,
+    };
+}
+function parseCompletionMode(value) {
+    if (["pr", "auto-merge", "direct-merge", "none"].includes(value))
+        return value;
+    fail("--completion must be one of: pr, auto-merge, direct-merge, none");
+}
+function parseReviewProviderOption(value, cwd) {
+    if (value === "auto")
+        return providerFromSaved("auto", cwd);
+    if (value === "github" || value === "gitlab")
+        return value;
+    fail("--provider must be one of: auto, github, gitlab");
+}
+function parseOptionalPositiveInteger(value, label) {
+    if (!value.trim())
+        return null;
+    const parsed = Number.parseInt(value, 10);
+    if (Number.isInteger(parsed) && parsed > 0)
+        return parsed;
+    fail(`${label} must be a positive integer or blank`);
+}
+function providerFromSaved(value, cwd) {
+    if (value === "github" || value === "gitlab")
+        return value;
+    if (value === "local")
+        return undefined;
+    return detectGitProvider(cwd);
+}
 function branchContinueTicketHelp(cwd, flag = "--continue") {
     const sessions = findResumableBranchSessions(join(cwd, ".foreman"));
     if (sessions.length === 0) {
@@ -93,6 +169,40 @@ async function ensureGitHubReadyForCreatePr(cwd, log, yes) {
         }
     }
 }
+async function ensureReviewProviderReady(cwd, provider, log, yes) {
+    if (provider === "github") {
+        await ensureGitHubReadyForCreatePr(cwd, log, yes);
+        return;
+    }
+    while (true) {
+        const result = preflightGlab(cwd);
+        if (result.ok)
+            return;
+        log.write("gitlab-readiness-failed", {
+            code: result.code,
+            message: result.message,
+            repairCommands: result.repairCommands,
+            command: result.command,
+            output: result.output,
+        });
+        const detail = formatGitHubFailure(result);
+        if (yes || !process.stdin.isTTY || !process.stdout.isTTY) {
+            fail(`GitLab MR setup failed before building:\n${detail}`);
+        }
+        console.error(`foreman: GitLab MR setup failed before building:\n${detail}\n`);
+        const action = await select({
+            message: "Retry GitLab readiness check?",
+            options: [
+                { value: "retry", label: "Retry" },
+                { value: "cancel", label: "Cancel" },
+            ],
+        });
+        if (isCancel(action) || action === "cancel") {
+            console.log("ai-foreman: cancelled");
+            process.exit(0);
+        }
+    }
+}
 export function buildStartCommand() {
     return new Command("start")
         .description("Enlist a builder and drive it through a batch of N steps.")
@@ -108,14 +218,21 @@ export function buildStartCommand() {
         .option("--fast", "fast mode — lower latency (maps to effort=low for codex)")
         .option("--no-qa", "disable per-ticket QA review (enabled by default)")
         .option("--branch-per-ticket", "run each selected structured ticket in an isolated git worktree and branch")
+        .option("--no-branch-per-ticket", "disable saved branch-per-ticket defaults for this run")
         .option("--create-pr", "push each successful ticket branch and create a GitHub PR (implies --branch-per-ticket)")
+        .option("--no-create-pr", "disable saved PR/MR creation defaults for this run")
+        .option("--completion <mode>", "ticket branch completion behavior (pr | auto-merge | direct-merge | none)")
+        .option("--provider <provider>", "PR/MR provider for branch completion (auto | github | gitlab)")
+        .option("--auto-merge-wait", "wait for dependency PR/MRs to merge before starting dependent tickets")
+        .option("--no-auto-merge-wait", "do not wait for dependency PR/MRs before dependent tickets")
+        .option("--auto-merge-timeout-minutes <n>", "auto-merge dependency wait timeout in minutes (blank means no timeout)")
         .option("--base <ref>", "base ref for root ticket branches (default: current branch or HEAD)")
         .option("--branch-prefix <prefix>", "branch name prefix for ticket branches", "rafi")
         .option("--max-branch-depth <n>", "maximum selected branch stack depth", "2")
         .option("--pr-ready", "create ready-for-review PRs instead of draft PRs")
         .option("--keep-worktrees", "keep successful ticket worktrees for inspection")
         .option("--ticket <id>", "ticket id to continue in branch mode; repeat for multiple tickets", collectTicket, [])
-        .action(async (project, opts) => {
+        .action(async (project, opts, command) => {
         const steps = Number.parseInt(opts.steps, 10);
         if (!Number.isInteger(steps) || steps < 1) {
             fail("--steps must be a positive integer");
@@ -127,6 +244,7 @@ export function buildStartCommand() {
         const cwd = resolve(project);
         if (!existsSync(cwd))
             fail(`project directory not found: ${cwd}`);
+        const branchDefaults = resolveStartBranchDefaults(cwd, opts, command);
         let agent;
         try {
             agent = resolveAgentForProject(cwd, opts.agent);
@@ -165,7 +283,7 @@ export function buildStartCommand() {
         if (opts.resume && opts.continue) {
             fail("choose either --resume <sessionId> or --continue, not both");
         }
-        const branchMode = Boolean(opts.branchPerTicket || opts.createPr);
+        const branchMode = branchDefaults.branchMode;
         const continueTickets = opts.ticket ?? [];
         const maxBranchDepth = Number.parseInt(opts.maxBranchDepth, 10);
         if (!Number.isInteger(maxBranchDepth) || maxBranchDepth < 1) {
@@ -188,6 +306,9 @@ export function buildStartCommand() {
                 fail("--tickets is not supported with --branch-per-ticket; initialize and use .tickets/tickets.yaml");
             if (!isTicketsInitialized(cwd))
                 fail("--branch-per-ticket requires initialized .tickets/ (run ai-foreman tickets init)");
+            if (branchDefaults.createReview && !branchDefaults.reviewProvider) {
+                fail("PR/MR completion is enabled but no GitHub or GitLab origin remote was detected; pass --provider github|gitlab or --completion none");
+            }
         }
         const resumeSessionId = opts.resume ??
             (!branchMode && opts.continue ? findLastSessionId(join(cwd, ".foreman")) : undefined);
@@ -225,8 +346,8 @@ export function buildStartCommand() {
             catch (err) {
                 fail(err instanceof Error ? err.message : String(err));
             }
-            if (opts.createPr) {
-                await ensureGitHubReadyForCreatePr(cwd, log, Boolean(opts.yes));
+            if (branchDefaults.createReview && branchDefaults.reviewProvider) {
+                await ensureReviewProviderReady(cwd, branchDefaults.reviewProvider, log, Boolean(opts.yes));
             }
             const ready = await ensureRuntimeReadyForCommand(cwd, agent, {
                 label: "start",
@@ -290,6 +411,7 @@ export function buildStartCommand() {
                     baseRef: opts.base ?? currentGitRef(cwd),
                     branchPrefix: opts.branchPrefix,
                     maxBranchDepth,
+                    rootBaseBranches: branchDefaults.rootBaseBranches,
                 });
                 let auditBuilder;
                 let auditViewer;
@@ -304,6 +426,7 @@ export function buildStartCommand() {
                         branchPrefix: opts.branchPrefix,
                         maxBranchDepth,
                         auditDependencies,
+                        rootBaseBranches: branchDefaults.rootBaseBranches,
                     });
                     log.write("branch-plan", {
                         baseRef: plan.baseRef,
@@ -353,9 +476,14 @@ export function buildStartCommand() {
                 fast: opts.fast,
                 notificationsEnabled: config.notifications.enabled,
                 qaEnabled,
-                createPr: Boolean(opts.createPr),
-                prReady: Boolean(opts.prReady),
+                createPr: branchDefaults.createReview,
+                completionMode: branchDefaults.completionMode,
+                reviewProvider: branchDefaults.reviewProvider,
+                prReady: branchDefaults.prReady,
                 keepWorktrees: Boolean(opts.keepWorktrees),
+                cleanupBranches: branchDefaults.cleanupBranches,
+                autoMergeWait: branchDefaults.autoMergeWait,
+                autoMergeTimeoutMinutes: branchDefaults.autoMergeTimeoutMinutes,
                 allowedBaseDirtyPaths,
                 trackerPaths: {
                     progressDoc: ticketsConfig.paths.progressDoc,
@@ -366,7 +494,7 @@ export function buildStartCommand() {
                 observeBuilder: (builder) => printEvents(builder.events()),
             });
             console.log("foreman: branch run summary");
-            console.log("ticket\tbranch\tbase\tstatus\tcommit\tpush\tpr");
+            console.log("ticket\tbranch\tbase\tstatus\tcommit\tpush\tcompletion");
             for (const row of summaries) {
                 console.log([
                     row.ticket,

package/dist/cli/tickets.d.ts

@@ -14,4 +14,15 @@ export declare function buildPopulateAgentRunOptions(opts: {
     yes?: boolean;
     log: Log;
 }): RoleBuilderOptions;
+interface PopulateCommandOptions {
+    project?: string;
+    agent?: string;
+    model?: string;
+    effort?: string;
+    sources?: string[];
+    fast?: boolean;
+    yes?: boolean;
+}
+export declare function cmdPopulateCli(opts: PopulateCommandOptions): Promise<void>;
 export declare function buildTicketsCommand(): Command;
+export {};