ai-foreman 1.4.0 → 1.6.0

package/dist/adapters/codex.js

@@ -77,6 +77,7 @@ export class CodexAdapter {
         const args = [
             "exec",
             "--json",
+            "--skip-git-repo-check",
             "--sandbox",
             this.opts.sandboxMode ?? "workspace-write",
             "-C",

package/dist/agentRun.d.ts

@@ -16,7 +16,7 @@ export interface RoleBuilderOptions {
     yes?: boolean;
     allowSwitch?: boolean;
     label: string;
-    log: Log;
+    log?: Log;
     permissionConfig?: PermissionConfig;
     extraSkills?: string[];
     sandboxMode?: BuilderAdapterOptions["sandboxMode"];
@@ -29,11 +29,12 @@ export interface RoleBuilder {
     effort?: EffortLevel;
     roleBundle: RoleBundle;
     skills: string[];
+    log: Log;
 }
 export interface RoleInstructionRunOptions extends Omit<RoleBuilderOptions, "log"> {
     instruction: string;
     logPath?: string;
-    logEvent?: "rafi-plan" | "ticket-populate" | "preflight";
+    logEvent?: "rafi-plan" | "ticket-populate" | "preflight" | "uninstall-proposal";
 }
 export interface RoleInstructionRunResult {
     turn: {
@@ -43,6 +44,7 @@ export interface RoleInstructionRunResult {
     runtime: AgentRuntime;
     model?: string;
     effort?: EffortLevel;
+    sessionId?: string;
     logPath: string;
     roleBundle: RoleBundle;
     skills: string[];

package/dist/agentRun.js

@@ -1,4 +1,4 @@
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { loadConfig, DEFAULT_CONFIG } from "./config.js";
 import { Log } from "./log.js";
@@ -10,6 +10,7 @@ import { printEvents } from "./cli/events.js";
 import { loadRoleBundle } from "./roles.js";
 import { ensureRuntimeReadyForCommand } from "./cli/runtimeAuthPrompt.js";
 import { resolveAgentForProject } from "./cli/runtimeSelection.js";
+import { parse as parseYaml } from "yaml";
 export const VALID_EFFORT = ["low", "medium", "high", "xhigh"];
 export function assertEffortLevel(effort) {
     if (effort && !VALID_EFFORT.includes(effort)) {
@@ -84,12 +85,16 @@ export async function createRoleBuilder(opts) {
     if (!existsSync(opts.projectDir)) {
         throw new Error(`project directory not found: ${opts.projectDir}`);
     }
-    assertEffortLevel(opts.effort);
-    let runtime = resolveAgentForProject(opts.projectDir, opts.agent);
+    const saved = readRoleDefaults(opts.projectDir, opts.role);
+    const configuredEffort = saved?.reasoning && saved.reasoning !== "default" ? saved.reasoning : undefined;
+    const effectiveEffort = opts.effort ?? (VALID_EFFORT.includes(configuredEffort) ? configuredEffort : undefined);
+    assertEffortLevel(effectiveEffort);
+    let runtime = resolveAgentForProject(opts.projectDir, opts.agent ?? saved?.make);
     const config = loadConfig(join(opts.projectDir, "foreman.yaml"));
+    const log = opts.log ?? new Log(makeLogPath(opts.projectDir, opts.label.replace(/\s+/g, "-")));
     const roleBundle = loadRoleBundle(opts.role, { projectDir: opts.projectDir });
-    const initialModel = opts.model ?? roleBundle.model ?? undefined;
-    const effort = opts.effort ?? roleBundle.effort ?? undefined;
+    const initialModel = opts.model ?? (saved?.model !== "default" ? saved?.model : undefined) ?? roleBundle.model ?? undefined;
+    const effort = effectiveEffort ?? roleBundle.effort ?? undefined;
     const ready = await ensureRuntimeReadyForCommand(opts.projectDir, runtime, {
         label: opts.label,
         yes: Boolean(opts.yes),
@@ -104,9 +109,9 @@ export async function createRoleBuilder(opts) {
         cwd: opts.projectDir,
         model,
         resumeSessionId: opts.resumeSessionId,
-        permission: createPermissionHandler(policy, opts.log),
+        permission: createPermissionHandler(policy, log),
         effort,
-        fast: opts.fast,
+        fast: opts.fast ?? saved?.fast,
         sandboxMode: opts.sandboxMode,
         systemPromptAppend: roleBundle.system || undefined,
         skills: skills.length > 0 ? skills : undefined,
@@ -114,7 +119,21 @@ export async function createRoleBuilder(opts) {
     const builder = runtime === "codex"
         ? new CodexAdapter(adapterOpts)
         : await ClaudeAdapter.create(adapterOpts);
-    return { builder, runtime, model, effort, roleBundle, skills };
+    return { builder, runtime, model, effort, roleBundle, skills, log };
+}
+function readRoleDefaults(projectDir, role) {
+    const path = join(projectDir, "rafi-config.yaml");
+    if (!existsSync(path))
+        return undefined;
+    try {
+        const config = parseYaml(readFileSync(path, "utf8"));
+        return config?.agent_defaults?.version === 1
+            ? config.agent_defaults.roles[role]
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
 }
 export async function runRoleInstruction(opts) {
     const logPath = opts.logPath ?? makeLogPath(opts.projectDir, opts.label.replace(/\s+/g, "-"));
@@ -133,6 +152,10 @@ export async function runRoleInstruction(opts) {
         if (opts.logEvent) {
             log.write(opts.logEvent, {
                 role: opts.role,
+                runtime,
+                model,
+                effort,
+                sessionId: builder.sessionId(),
                 statusKind: turn.status.kind,
                 summary: turn.status.summary,
                 reason: turn.status.reason,
@@ -140,7 +163,7 @@ export async function runRoleInstruction(opts) {
                 isError: turn.result.isError,
             });
         }
-        return { turn, runtime, model, effort, logPath, roleBundle, skills };
+        return { turn, runtime, model, effort, sessionId: builder.sessionId(), logPath, roleBundle, skills };
     }
     catch (err) {
         await builder.close().catch(() => { });

package/dist/branch/git.d.ts

@@ -14,6 +14,7 @@ export declare function generatedTrackerDirtyPaths(paths: {
 export declare function ensureCleanBaseWorktree(cwd: string, opts?: BaseWorktreeCleanOptions): void;
 export declare function ensureForemanExcluded(cwd: string): void;
 export declare function createTicketWorktree(projectDir: string, runId: string, branch: string, base: string): string;
+export declare function findWorktreeForBranch(projectDir: string, branch: string): string | undefined;
 export declare function removeTicketWorktree(projectDir: string, worktreePath: string): void;
 export declare function currentWorktreeBranch(worktreePath: string): string;
 export declare function hasTrackerChanges(worktreePath: string, paths?: {
@@ -24,5 +25,7 @@ export declare function hasWorktreeChanges(worktreePath: string): boolean;
 export declare function commitAll(worktreePath: string, message: string): string | undefined;
 export declare function headCommitIfAhead(worktreePath: string, base: string): string | undefined;
 export declare function pushBranch(worktreePath: string, branch: string): void;
+export declare function mergeBranchToLocalBase(projectDir: string, branch: string, baseBranch: string, message: string, method?: "squash" | "merge" | "rebase"): string;
+/** Compatibility export for callers compiled against the older helper. */
 export declare function squashMergeBranchToLocalBase(projectDir: string, branch: string, baseBranch: string, message: string): string;
 export declare function deleteLocalBranch(projectDir: string, branch: string): void;

package/dist/branch/git.js

@@ -51,6 +51,19 @@ export function createTicketWorktree(projectDir, runId, branch, base) {
     runGit(projectDir, ["worktree", "add", "-b", branch, worktreePath, base]);
     return worktreePath;
 }
+export function findWorktreeForBranch(projectDir, branch) {
+    const output = runGit(projectDir, ["worktree", "list", "--porcelain"]).stdout;
+    let worktree;
+    for (const line of output.split(/\r?\n/)) {
+        if (line.startsWith("worktree "))
+            worktree = line.slice("worktree ".length);
+        if (line === `branch refs/heads/${branch}` && worktree)
+            return worktree;
+        if (!line.trim())
+            worktree = undefined;
+    }
+    return undefined;
+}
 export function removeTicketWorktree(projectDir, worktreePath) {
     try {
         runGit(projectDir, ["worktree", "remove", "--force", worktreePath]);
@@ -101,15 +114,28 @@ export function headCommitIfAhead(worktreePath, base) {
 export function pushBranch(worktreePath, branch) {
     runGit(worktreePath, ["push", "-u", "origin", branch]);
 }
-export function squashMergeBranchToLocalBase(projectDir, branch, baseBranch, message) {
-    const current = currentGitRef(projectDir);
-    if (current !== baseBranch) {
+export function mergeBranchToLocalBase(projectDir, branch, baseBranch, message, method = "squash") {
+    if (method === "rebase")
+        runGit(projectDir, ["rebase", baseBranch, branch]);
+    if (currentGitRef(projectDir) !== baseBranch) {
         runGit(projectDir, ["checkout", baseBranch]);
     }
-    runGit(projectDir, ["merge", "--squash", branch]);
-    runGit(projectDir, ["commit", "-m", message]);
+    if (method === "squash") {
+        runGit(projectDir, ["merge", "--squash", branch]);
+        runGit(projectDir, ["commit", "-m", message]);
+    }
+    else if (method === "merge") {
+        runGit(projectDir, ["merge", "--no-ff", branch, "-m", message]);
+    }
+    else {
+        runGit(projectDir, ["merge", "--ff-only", branch]);
+    }
     return runGit(projectDir, ["rev-parse", "--short", "HEAD"]).stdout;
 }
+/** Compatibility export for callers compiled against the older helper. */
+export function squashMergeBranchToLocalBase(projectDir, branch, baseBranch, message) {
+    return mergeBranchToLocalBase(projectDir, branch, baseBranch, message, "squash");
+}
 export function deleteLocalBranch(projectDir, branch) {
     try {
         runGit(projectDir, ["branch", "-D", branch]);

package/dist/branch/github.d.ts

@@ -1,4 +1,4 @@
-import type { BranchPlanNode, GitHubFailure, GitHubOperationResult, GitHubReadinessResult, GitHubRemote, GitHubRemoteResult, PrResult, ReviewMergeStatus } from "./types.js";
+import type { BranchPlanNode, GitHubFailure, GitHubOperationResult, GitHubReadinessResult, GitHubRemote, GitHubRemoteResult, PrResult, ReviewMergeStatus, MergeMethod } from "./types.js";
 export declare function inspectGitHubRemote(cwd: string): GitHubRemoteResult;
 export declare function originLooksLikeGitHub(cwd: string): boolean;
 export declare function checkGitHubReadiness(cwd: string): GitHubReadinessResult;
@@ -17,7 +17,7 @@ export interface CreatePrOptions {
     commit?: string;
 }
 export declare function createOrReusePr(cwd: string, opts: CreatePrOptions): PrResult;
-export declare function enableGitHubAutoMerge(cwd: string, branch: string, cleanup: boolean): PrResult;
+export declare function enableGitHubAutoMerge(cwd: string, branch: string, cleanup: boolean, method?: MergeMethod): PrResult;
 export declare function checkGitHubPrMerged(cwd: string, branch: string): ReviewMergeStatus;
 export declare function formatGitHubFailure(failure: GitHubFailure): string;
 export {};

package/dist/branch/github.js

@@ -157,8 +157,8 @@ export function createOrReusePr(cwd, opts) {
         return { status: "created", url: created.stdout };
     return prFailure(classifyPrFailure(created, opts.node.branch, "Failed to create GitHub PR.", remoteForRepair));
 }
-export function enableGitHubAutoMerge(cwd, branch, cleanup) {
-    const args = ["pr", "merge", branch, "--auto", "--squash"];
+export function enableGitHubAutoMerge(cwd, branch, cleanup, method = "squash") {
+    const args = ["pr", "merge", branch, "--auto", `--${method}`];
     if (cleanup)
         args.push("--delete-branch");
     const result = runCommand(cwd, "gh", args, 30_000);

package/dist/branch/gitlab.d.ts

@@ -1,4 +1,4 @@
-import type { BranchPlanNode, GitHubOperationResult, PrResult, ReviewMergeStatus } from "./types.js";
+import type { BranchPlanNode, GitHubOperationResult, PrResult, ReviewMergeStatus, MergeMethod } from "./types.js";
 export declare function preflightGlab(cwd: string): GitHubOperationResult;
 export declare function pushBranchForMr(cwd: string, branch: string): GitHubOperationResult;
 export interface CreateMrOptions {
@@ -9,7 +9,8 @@ export interface CreateMrOptions {
     commit?: string;
     autoMerge?: boolean;
     cleanup?: boolean;
+    mergeMethod?: MergeMethod;
 }
 export declare function createOrReuseMr(cwd: string, opts: CreateMrOptions): PrResult;
-export declare function enableGitLabAutoMerge(cwd: string, branch: string, cleanup: boolean): PrResult;
+export declare function enableGitLabAutoMerge(cwd: string, branch: string, cleanup: boolean, method?: MergeMethod): PrResult;
 export declare function checkGitLabMrMerged(cwd: string, branch: string): ReviewMergeStatus;

package/dist/branch/gitlab.js

@@ -77,7 +77,9 @@ export function createOrReuseMr(cwd, opts) {
     if (!opts.ready)
         args.push("--draft");
     if (opts.autoMerge)
-        args.push("--auto-merge", "--squash-before-merge");
+        args.push("--auto-merge");
+    if (opts.mergeMethod === "squash")
+        args.push("--squash-before-merge");
     if (opts.cleanup)
         args.push("--remove-source-branch");
     const created = runCommand(cwd, "glab", args);
@@ -88,15 +90,19 @@ export function createOrReuseMr(cwd, opts) {
         "glab auth status",
     ]));
 }
-export function enableGitLabAutoMerge(cwd, branch, cleanup) {
-    const args = ["mr", "merge", branch, "--auto-merge", "--squash", "--yes"];
+export function enableGitLabAutoMerge(cwd, branch, cleanup, method = "squash") {
+    const args = ["mr", "merge", branch, "--auto-merge", "--yes"];
+    if (method === "squash")
+        args.push("--squash");
+    if (method === "rebase")
+        args.push("--rebase");
     if (cleanup)
         args.push("--remove-source-branch");
     const result = runCommand(cwd, "glab", args, 30_000);
     if (result.ok)
         return { status: "auto_merge_enabled", url: result.stdout };
     return prFailure(classifyCommandFailure(result, "mr_create_failed", `Failed to enable GitLab MR auto-merge. Branch: ${branch}`, [
-        `glab mr merge ${branch} --auto-merge --squash --yes`,
+        `glab mr merge ${branch} --auto-merge${method === "squash" ? " --squash" : method === "rebase" ? " --rebase" : ""} --yes`,
         "glab auth status",
     ]));
 }

package/dist/branch/planner.d.ts

@@ -13,8 +13,10 @@ export interface BuildBranchPlanOptions {
     maxBranchDepth: number;
     auditDependencies?: AuditDependency[];
     rootBaseBranches?: boolean;
+    ticketIds?: string[];
 }
 export declare function buildBranchPlan(tickets: TicketDef[], states: Map<string, TicketState>, opts: BuildBranchPlanOptions): BranchPlan;
-export declare function selectTicketsForBranchRun(tickets: TicketDef[], states: Map<string, TicketState>, steps: number): TicketDef[];
+export declare function selectTicketsForBranchRun(tickets: TicketDef[], states: Map<string, TicketState>, steps: number, ticketIds?: string[]): TicketDef[];
+export declare function applySharedDeliveryBranch(plan: BranchPlan, unitId: string, allRemainingTicketIds: string[], branchPrefix?: string): BranchPlan;
 export declare function parseAuditDependencies(text: string): AuditDependency[];
 export declare function buildBranchAuditInstruction(tickets: TicketDef[]): string;

package/dist/branch/planner.js

@@ -1,5 +1,5 @@
 export function buildBranchPlan(tickets, states, opts) {
-    const selected = selectTicketsForBranchRun(tickets, states, opts.steps);
+    const selected = selectTicketsForBranchRun(tickets, states, opts.steps, opts.ticketIds);
     const selectedIds = new Set(selected.map((ticket) => ticket.id));
     const issues = [];
     const dependencyMap = new Map();
@@ -75,9 +75,12 @@ export function buildBranchPlan(tickets, states, opts) {
     }
     return { baseRef: opts.baseRef, nodes: selected.map((ticket) => nodeById.get(ticket.id)), issues };
 }
-export function selectTicketsForBranchRun(tickets, states, steps) {
+export function selectTicketsForBranchRun(tickets, states, steps, ticketIds) {
+    const allowed = ticketIds ? new Set(ticketIds) : undefined;
     const remaining = tickets
         .filter((ticket) => {
+        if (allowed && !allowed.has(ticket.id))
+            return false;
         const status = states.get(ticket.id)?.status ?? "planned";
         return status !== "done" && status !== "canceled";
     })
@@ -96,6 +99,25 @@ export function selectTicketsForBranchRun(tickets, states, steps) {
     }
     return selected;
 }
+export function applySharedDeliveryBranch(plan, unitId, allRemainingTicketIds, branchPrefix = "rafi") {
+    if (plan.nodes.length === 0)
+        return plan;
+    const slug = unitId.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "group";
+    const branch = `${branchPrefix.replace(/^\/+|\/+$/g, "") || "rafi"}/${slug}`;
+    const finalSelected = plan.nodes.at(-1)?.ticket.id;
+    const completesUnit = plan.nodes.length === allRemainingTicketIds.length
+        && allRemainingTicketIds.every((id) => plan.nodes.some((node) => node.ticket.id === id));
+    return {
+        ...plan,
+        nodes: plan.nodes.map((node) => ({
+            ...node,
+            branch,
+            baseBranch: plan.baseRef,
+            deliveryUnitId: unitId,
+            deliveryUnitFinal: completesUnit && node.ticket.id === finalSelected,
+        })),
+    };
+}
 export function parseAuditDependencies(text) {
     const deps = [];
     for (const line of text.split(/\r?\n/)) {

package/dist/branch/runner.d.ts

@@ -1,6 +1,14 @@
 import type { BuilderAdapter, EffortLevel } from "../adapters/types.js";
 import type { Log } from "../log.js";
-import type { BranchPlan, BranchPlanNode, BranchRunSummary, CompletionMode, ReviewProvider } from "./types.js";
+import type { BranchPlan, BranchPlanNode, BranchRunSummary, CompletionMode, MergeMethod, ReviewProvider } from "./types.js";
+export interface DeliveryUnitSession {
+    unitId: string;
+    branch: string;
+    worktreePath: string;
+    sessionId: string;
+    ticket: string;
+}
+export declare function readDeliveryUnitSession(projectDir: string, unitId: string): DeliveryUnitSession | undefined;
 export interface BranchRunnerOptions {
     projectDir: string;
     runId: string;
@@ -20,6 +28,7 @@ export interface BranchRunnerOptions {
     cleanupBranches?: boolean;
     autoMergeWait?: boolean;
     autoMergeTimeoutMinutes?: number | null;
+    mergeMethod?: MergeMethod;
     allowedBaseDirtyPaths?: string[];
     trackerPaths?: {
         progressDoc: string;

package/dist/branch/runner.js

@@ -1,9 +1,25 @@
 import { Foreman, MARKER_SPEC } from "../foreman.js";
 import { fireNotification } from "../notify.js";
 import { cmdBlock, cmdComplete, cmdUpdate } from "../tickets/commands.js";
-import { commitAll, createTicketWorktree, currentWorktreeBranch, deleteLocalBranch, ensureCleanBaseWorktree, ensureForemanExcluded, hasTrackerChanges, hasWorktreeChanges, headCommitIfAhead, removeTicketWorktree, squashMergeBranchToLocalBase, } from "./git.js";
+import { commitAll, createTicketWorktree, findWorktreeForBranch, currentWorktreeBranch, deleteLocalBranch, ensureCleanBaseWorktree, ensureForemanExcluded, hasTrackerChanges, hasWorktreeChanges, headCommitIfAhead, removeTicketWorktree, mergeBranchToLocalBase, } from "./git.js";
 import { checkGitHubPrMerged, createOrReusePr, enableGitHubAutoMerge, pushBranchForPr } from "./github.js";
 import { checkGitLabMrMerged, createOrReuseMr, enableGitLabAutoMerge, pushBranchForMr } from "./gitlab.js";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+export function readDeliveryUnitSession(projectDir, unitId) {
+    const path = deliverySessionPath(projectDir, unitId);
+    if (!existsSync(path))
+        return undefined;
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+function deliverySessionPath(projectDir, unitId) {
+    return join(projectDir, ".foreman", "delivery-sessions", `${unitId}.json`);
+}
 export async function runBranchPlan(opts) {
     ensureCleanBaseWorktree(opts.projectDir, { allowedDirtyPaths: opts.allowedBaseDirtyPaths });
     ensureForemanExcluded(opts.projectDir);
@@ -29,6 +45,9 @@ export async function runBranchPlan(opts) {
     if (opts.plan.issues.some((issue) => issue.blocking))
         return summaries;
     for (const node of orderNodes(opts.plan.nodes)) {
+        const sharedUnit = Boolean(node.deliveryUnitId);
+        const completesSharedUnit = !sharedUnit || Boolean(node.deliveryUnitFinal);
+        const createsReviewForNode = createsReview && completesSharedUnit;
         const missingDependency = node.dependencies.find((dep) => !successfulBranches.has(dep));
         if (missingDependency) {
             const detail = `dependency ${missingDependency} did not complete`;
@@ -42,7 +61,7 @@ export async function runBranchPlan(opts) {
             notifyIssue(opts.notificationsEnabled, detail);
             continue;
         }
-        if (createsReview) {
+        if (createsReview && !sharedUnit) {
             const missingPush = node.dependencies.find((dep) => {
                 const depNode = opts.plan.nodes.find((candidate) => candidate.ticket.id === dep);
                 return depNode && !pushedBranches.has(depNode.branch);
@@ -60,7 +79,7 @@ export async function runBranchPlan(opts) {
                 continue;
             }
         }
-        if (completionMode === "auto-merge" && node.dependencies.length > 0) {
+        if (completionMode === "auto-merge" && node.dependencies.length > 0 && !sharedUnit) {
             const mergeReadiness = await waitForAutoMergeDependencies(opts, node, reviewProvider);
             if (!mergeReadiness.ok) {
                 summaries.push(summaryFor(node, "skipped", mergeReadiness.message, "skipped"));
@@ -85,6 +104,7 @@ export async function runBranchPlan(opts) {
         });
         const resumeSession = opts.resumeSessions?.get(node.ticket.id);
         const worktreePath = resumeSession?.worktreePath
+            ?? (sharedUnit ? findWorktreeForBranch(opts.projectDir, node.branch) : undefined)
             ?? createTicketWorktree(opts.projectDir, opts.runId, node.branch, node.baseBranch);
         node.worktreePath = worktreePath;
         let builder;
@@ -127,6 +147,11 @@ export async function runBranchPlan(opts) {
                     prReady: opts.prReady,
                     keepWorktrees: opts.keepWorktrees,
                 });
+                if (node.deliveryUnitId) {
+                    const path = deliverySessionPath(opts.projectDir, node.deliveryUnitId);
+                    mkdirSync(join(opts.projectDir, ".foreman", "delivery-sessions"), { recursive: true });
+                    writeFileSync(path, `${JSON.stringify({ unitId: node.deliveryUnitId, branch: node.branch, worktreePath, sessionId, ticket: node.ticket.id }, null, 2)}\n`, "utf8");
+                }
             }
             opts.log.write("step", {
                 index: summaries.length + 1,
@@ -180,12 +205,12 @@ export async function runBranchPlan(opts) {
             if (hasWorktreeChanges(worktreePath)) {
                 commit = commitAll(worktreePath, `${node.ticket.id}: ${node.ticket.title}`);
             }
-            if (!commit && (createsReview || completionMode === "direct-merge")) {
+            if (!commit && (createsReviewForNode || (completionMode === "direct-merge" && completesSharedUnit))) {
                 commit = headCommitIfAhead(worktreePath, node.baseBranch);
             }
             const summary = summaryFor(node, "done", commit ? undefined : "no_changes");
             summary.commit = commit;
-            if (commit && createsReview) {
+            if (commit && createsReviewForNode) {
                 const push = reviewProvider === "gitlab"
                     ? pushBranchForMr(worktreePath, node.branch)
                     : pushBranchForPr(worktreePath, node.branch);
@@ -226,8 +251,9 @@ export async function runBranchPlan(opts) {
                         runId: opts.runId,
                         qaEvidence: qaSummary,
                         commit,
-                        autoMerge: completionMode === "auto-merge",
+                        autoMerge: false,
                         cleanup: opts.cleanupBranches ?? true,
+                        mergeMethod: opts.mergeMethod ?? "squash",
                     })
                     : createOrReusePr(opts.projectDir, {
                         node,
@@ -248,7 +274,7 @@ export async function runBranchPlan(opts) {
                     continue;
                 }
                 if (completionMode === "auto-merge" && reviewProvider === "github") {
-                    const autoMerge = enableGitHubAutoMerge(opts.projectDir, node.branch, opts.cleanupBranches ?? true);
+                    const autoMerge = enableGitHubAutoMerge(opts.projectDir, node.branch, opts.cleanupBranches ?? true, opts.mergeMethod ?? "squash");
                     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));
@@ -258,8 +284,8 @@ export async function runBranchPlan(opts) {
                     }
                     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);
+                else if (completionMode === "auto-merge" && reviewProvider === "gitlab") {
+                    const autoMerge = enableGitLabAutoMerge(opts.projectDir, node.branch, opts.cleanupBranches ?? true, opts.mergeMethod ?? "squash");
                     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));
@@ -270,14 +296,14 @@ export async function runBranchPlan(opts) {
                     opts.log.write("mr-auto-merge-enabled", { ticket: node.ticket.id, branch: node.branch, url: summary.pr.url });
                 }
             }
-            else if (createsReview) {
+            else if (createsReviewForNode) {
                 summary.pushStatus = "skipped";
                 summary.pr = { status: "skipped", error: commit ? undefined : "no_changes" };
             }
-            else if (commit && completionMode === "direct-merge") {
+            else if (commit && completionMode === "direct-merge" && completesSharedUnit) {
                 if (!opts.keepWorktrees)
                     removeTicketWorktree(opts.projectDir, worktreePath);
-                const mergeCommit = squashMergeBranchToLocalBase(opts.projectDir, node.branch, node.baseBranch, `${node.ticket.id}: ${node.ticket.title}`);
+                const mergeCommit = mergeBranchToLocalBase(opts.projectDir, node.branch, node.baseBranch, `${node.ticket.id}: ${node.ticket.title}`, opts.mergeMethod ?? "squash");
                 summary.pr = { status: "merged", url: mergeCommit };
                 opts.log.write("branch-direct-merge", {
                     ticket: node.ticket.id,
@@ -304,7 +330,9 @@ export async function runBranchPlan(opts) {
                 status: "done",
                 detail: summary.detail,
             });
-            if (!opts.keepWorktrees && completionMode !== "direct-merge")
+            if (node.deliveryUnitId && node.deliveryUnitFinal)
+                rmSync(deliverySessionPath(opts.projectDir, node.deliveryUnitId), { force: true });
+            if (!opts.keepWorktrees && completionMode !== "direct-merge" && completesSharedUnit)
                 removeTicketWorktree(opts.projectDir, worktreePath);
         }
         catch (err) {

package/dist/branch/types.d.ts

@@ -7,6 +7,9 @@ export interface BranchPlanNode {
     dependencies: string[];
     depth: number;
     worktreePath?: string;
+    /** Shared delivery units intentionally reuse one isolated branch/worktree. */
+    deliveryUnitId?: string;
+    deliveryUnitFinal?: boolean;
 }
 export interface BranchIssue {
     ticket?: string;
@@ -56,6 +59,7 @@ export interface BranchPlan {
 }
 export type CompletionMode = "none" | "pr" | "auto-merge" | "direct-merge";
 export type ReviewProvider = "github" | "gitlab";
+export type MergeMethod = "squash" | "merge" | "rebase";
 export interface PrResult {
     status: "created" | "existing" | "failed" | "skipped" | "auto_merge_enabled" | "merged";
     url?: string;

package/dist/buildRuns.d.ts

@@ -0,0 +1,35 @@
+import type { BuildRunRecordV1, ResolvedAgentSettings } from "rafi-spec";
+export declare const BUILD_RUN_VERSION = 1;
+export declare const BUILD_RUN_DIRECTORY = ".foreman/runs";
+export declare const BUILD_HEARTBEAT_MS = 10000;
+export declare const BUILD_LEASE_STALE_MS = 45000;
+export interface CreateBuildRunInput {
+    tickets: string[];
+    deliveryUnit?: string;
+    branchMode?: BuildRunRecordV1["branchMode"];
+    repositoryRoot: string;
+    worktree?: string;
+    branch?: string;
+    baseHead?: string;
+    startHead?: string;
+    builder?: ResolvedAgentSettings;
+    qa?: ResolvedAgentSettings;
+    now?: Date;
+}
+export declare function createBuildRun(input: CreateBuildRunInput): BuildRunRecordV1;
+export declare function saveBuildRun(projectDir: string, run: BuildRunRecordV1, now?: Date): BuildRunRecordV1;
+export declare function checkpointBuildRun(projectDir: string, run: BuildRunRecordV1, checkpoint: string, patch?: Partial<BuildRunRecordV1>): BuildRunRecordV1;
+export declare function persistBuildSession(projectDir: string, run: BuildRunRecordV1, role: "builder" | "qa", sessionId: string): BuildRunRecordV1;
+export declare function recordBuildReceipt(projectDir: string, run: BuildRunRecordV1, operationId: string, detail?: {
+    externalId?: string;
+    detail?: string;
+}): BuildRunRecordV1;
+export declare function heartbeatBuildRun(projectDir: string, run: BuildRunRecordV1, now?: Date): BuildRunRecordV1;
+export declare function releaseBuildLease(projectDir: string, run: BuildRunRecordV1, status?: BuildRunRecordV1["status"]): BuildRunRecordV1;
+export declare function completeBuildRun(projectDir: string, run: BuildRunRecordV1, now?: Date): BuildRunRecordV1;
+export declare function readBuildRuns(projectDir: string): BuildRunRecordV1[];
+export declare function recoverableBuildRuns(projectDir: string, now?: Date): Array<BuildRunRecordV1 & {
+    active: boolean;
+}>;
+export declare function isLeaseActive(run: BuildRunRecordV1, now?: Date): boolean;
+export declare function buildRecoveryPreview(run: BuildRunRecordV1): string[];