sequant 1.15.3 → 1.16.0

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "sequant",
   "description": "Structured workflow system for Claude Code - GitHub issue resolution with spec, exec, test, and QA phases",
-  "version": "1.15.3",
+  "version": "1.16.0",
   "author": {
     "name": "sequant-io",
     "email": "hello@sequant.io"

package/dist/bin/cli.js

@@ -44,6 +44,7 @@ import { statsCommand } from "../src/commands/stats.js";
 import { dashboardCommand } from "../src/commands/dashboard.js";
 import { stateInitCommand, stateRebuildCommand, stateCleanCommand, } from "../src/commands/state.js";
 import { syncCommand, areSkillsOutdated } from "../src/commands/sync.js";
+import { mergeCommand } from "../src/commands/merge.js";
 import { getManifest } from "../src/lib/manifest.js";
 const program = new Command();
 // Handle --no-color before parsing
@@ -142,8 +143,21 @@ program
     .option("--no-retry", "Disable automatic retry with MCP fallback (useful for debugging)")
     .option("--resume", "Resume from last completed phase (reads phase markers from GitHub)")
     .option("--no-rebase", "Skip pre-PR rebase onto origin/main (use when you want to handle rebasing manually)")
+    .option("--no-pr", "Skip PR creation after successful QA (manual PR workflow)")
     .option("-f, --force", "Force re-execution of completed issues (bypass pre-flight state guard)")
     .action(runCommand);
+program
+    .command("merge")
+    .description("Batch-level integration QA — verify feature branches before merging")
+    .argument("[issues...]", "Issue numbers to check (auto-detects from most recent run if omitted)")
+    .option("--check", "Run Phase 1 deterministic checks (default)")
+    .option("--scan", "Run Phase 1 + Phase 2 residual pattern detection")
+    .option("--review", "Run Phase 1 + 2 + 3 AI briefing")
+    .option("--all", "Run all phases")
+    .option("--post", "Post report to GitHub as PR comments")
+    .option("--json", "Output as JSON")
+    .option("-v, --verbose", "Enable verbose output")
+    .action(mergeCommand);
 program
     .command("logs")
     .description("View and analyze workflow run logs")

package/dist/src/commands/merge.d.ts

@@ -0,0 +1,22 @@
+/**
+ * sequant merge - Batch-level integration QA for completed runs
+ *
+ * Runs deterministic checks on feature branches from a `sequant run` batch
+ * to catch integration issues before human review.
+ *
+ * Phases:
+ * - --check (Phase 1): Combined branch test, mirroring, overlap detection
+ * - --scan  (Phase 1+2): Adds residual pattern detection
+ * - --review (Phase 1+2+3): Adds AI briefing (stub)
+ * - --all: Runs all phases
+ * - --post: Post report to GitHub PRs
+ */
+import type { MergeCommandOptions } from "../lib/merge-check/types.js";
+/**
+ * Determine exit code from batch verdict
+ */
+export declare function getExitCode(batchVerdict: string): number;
+/**
+ * Main merge command handler
+ */
+export declare function mergeCommand(issues: string[], options: MergeCommandOptions): Promise<void>;

package/dist/src/commands/merge.js

@@ -0,0 +1,109 @@
+/**
+ * sequant merge - Batch-level integration QA for completed runs
+ *
+ * Runs deterministic checks on feature branches from a `sequant run` batch
+ * to catch integration issues before human review.
+ *
+ * Phases:
+ * - --check (Phase 1): Combined branch test, mirroring, overlap detection
+ * - --scan  (Phase 1+2): Adds residual pattern detection
+ * - --review (Phase 1+2+3): Adds AI briefing (stub)
+ * - --all: Runs all phases
+ * - --post: Post report to GitHub PRs
+ */
+import { spawnSync } from "child_process";
+import { ui, colors } from "../lib/cli-ui.js";
+import { runMergeChecks, formatReportMarkdown, } from "../lib/merge-check/index.js";
+/**
+ * Determine exit code from batch verdict
+ */
+export function getExitCode(batchVerdict) {
+    switch (batchVerdict) {
+        case "READY":
+            return 0;
+        case "NEEDS_ATTENTION":
+            return 1;
+        case "BLOCKED":
+            return 2;
+        default:
+            return 1;
+    }
+}
+/**
+ * Get the git repository root
+ */
+function getRepoRoot() {
+    const result = spawnSync("git", ["rev-parse", "--show-toplevel"], {
+        stdio: "pipe",
+        encoding: "utf-8",
+    });
+    if (result.status !== 0) {
+        throw new Error("Not in a git repository");
+    }
+    return result.stdout.trim();
+}
+/**
+ * Main merge command handler
+ */
+export async function mergeCommand(issues, options) {
+    // Default to --check if no phase flag is specified
+    if (!options.check && !options.scan && !options.review && !options.all) {
+        options.check = true;
+    }
+    const repoRoot = getRepoRoot();
+    const issueNumbers = issues
+        .map((i) => parseInt(i, 10))
+        .filter((n) => !isNaN(n));
+    // Determine mode label
+    let mode = "check";
+    if (options.all)
+        mode = "all";
+    else if (options.review)
+        mode = "review";
+    else if (options.scan)
+        mode = "scan";
+    if (!options.json) {
+        console.log(ui.headerBox("SEQUANT MERGE"));
+        console.log("");
+        console.log(colors.muted(issueNumbers.length > 0
+            ? `Checking issues: ${issueNumbers.map((i) => `#${i}`).join(", ")} (mode: ${mode})`
+            : `Auto-detecting issues from most recent run (mode: ${mode})`));
+        console.log("");
+    }
+    try {
+        const report = await runMergeChecks(issueNumbers, options, repoRoot);
+        if (options.json) {
+            // JSON output: serialize the report (convert Map to object)
+            const jsonReport = {
+                ...report,
+                issueVerdicts: Object.fromEntries(report.issueVerdicts),
+            };
+            console.log(JSON.stringify(jsonReport, null, 2));
+        }
+        else {
+            // Markdown output
+            const markdown = formatReportMarkdown(report);
+            console.log(markdown);
+            // Phase 3 stub
+            if (options.review || options.all) {
+                console.log("");
+                console.log(colors.muted("Phase 3 (AI briefing) is not yet implemented. Use --check or --scan for deterministic checks."));
+            }
+        }
+        // Set exit code based on verdict
+        const exitCode = getExitCode(report.batchVerdict);
+        if (exitCode !== 0) {
+            process.exitCode = exitCode;
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (options.json) {
+            console.log(JSON.stringify({ error: message }, null, 2));
+        }
+        else {
+            console.error(ui.errorBox("Merge Check Failed", message));
+        }
+        process.exitCode = 2;
+    }
+}

package/dist/src/commands/run.d.ts

@@ -130,6 +130,36 @@ export interface RebaseResult {
  * @internal Exported for testing
  */
 export declare function rebaseBeforePR(worktreePath: string, issueNumber: number, packageManager: string | undefined, verbose: boolean): RebaseResult;
+/**
+ * Result of PR creation
+ */
+export interface PRCreationResult {
+    /** Whether PR creation was attempted */
+    attempted: boolean;
+    /** Whether PR was created successfully (or already existed) */
+    success: boolean;
+    /** PR number */
+    prNumber?: number;
+    /** PR URL */
+    prUrl?: string;
+    /** Error message if failed */
+    error?: string;
+}
+/**
+ * Push branch and create a PR after successful QA.
+ *
+ * Handles both fresh PR creation and detection of existing PRs.
+ * Failures are warnings — they don't fail the run.
+ *
+ * @param worktreePath Path to the worktree
+ * @param issueNumber Issue number
+ * @param issueTitle Issue title (for PR title)
+ * @param branch Branch name
+ * @param verbose Whether to show verbose output
+ * @returns PRCreationResult with PR info or error
+ * @internal Exported for testing
+ */
+export declare function createPR(worktreePath: string, issueNumber: number, issueTitle: string, branch: string, verbose: boolean, labels?: string[]): PRCreationResult;
 /**
  * Detect phases based on issue labels (like /solve logic)
  */
@@ -207,6 +237,12 @@ interface RunOptions {
      * Use when you want to preserve branch state or handle rebasing manually.
      */
     noRebase?: boolean;
+    /**
+     * Skip PR creation after successful QA.
+     * When true, branches are pushed but no PR is created.
+     * Useful for manual workflows where PRs are created separately.
+     */
+    noPr?: boolean;
     /**
      * Force re-execution of issues even if they have completed status.
      * Bypasses the pre-flight state guard that skips ready_for_merge/merged issues.

package/dist/src/commands/run.js

@@ -772,6 +772,140 @@ export function rebaseBeforePR(worktreePath, issueNumber, packageManager, verbos
         reinstalled,
     };
 }
+/**
+ * Push branch and create a PR after successful QA.
+ *
+ * Handles both fresh PR creation and detection of existing PRs.
+ * Failures are warnings — they don't fail the run.
+ *
+ * @param worktreePath Path to the worktree
+ * @param issueNumber Issue number
+ * @param issueTitle Issue title (for PR title)
+ * @param branch Branch name
+ * @param verbose Whether to show verbose output
+ * @returns PRCreationResult with PR info or error
+ * @internal Exported for testing
+ */
+export function createPR(worktreePath, issueNumber, issueTitle, branch, verbose, labels) {
+    // Step 1: Check for existing PR on this branch
+    const existingPR = spawnSync("gh", ["pr", "view", branch, "--json", "number,url"], { stdio: "pipe", cwd: worktreePath, timeout: 15000 });
+    if (existingPR.status === 0 && existingPR.stdout) {
+        try {
+            const prInfo = JSON.parse(existingPR.stdout.toString());
+            if (prInfo.number && prInfo.url) {
+                if (verbose) {
+                    console.log(chalk.gray(`    ℹ️  PR #${prInfo.number} already exists for branch ${branch}`));
+                }
+                return {
+                    attempted: true,
+                    success: true,
+                    prNumber: prInfo.number,
+                    prUrl: prInfo.url,
+                };
+            }
+        }
+        catch {
+            // JSON parse failed — no existing PR, continue to create
+        }
+    }
+    // Step 2: Push branch to remote
+    if (verbose) {
+        console.log(chalk.gray(`    🚀 Pushing branch ${branch} to origin...`));
+    }
+    const pushResult = spawnSync("git", ["-C", worktreePath, "push", "-u", "origin", branch], { stdio: "pipe", timeout: 60000 });
+    if (pushResult.status !== 0) {
+        const pushError = pushResult.stderr?.toString().trim() ?? "Unknown error";
+        console.log(chalk.yellow(`    ⚠️  git push failed: ${pushError}`));
+        return {
+            attempted: true,
+            success: false,
+            error: `git push failed: ${pushError}`,
+        };
+    }
+    // Step 3: Create PR
+    if (verbose) {
+        console.log(chalk.gray(`    📝 Creating PR for #${issueNumber}...`));
+    }
+    const isBug = labels?.some((l) => /^bug/i.test(l));
+    const prefix = isBug ? "fix" : "feat";
+    const prTitle = `${prefix}(#${issueNumber}): ${issueTitle}`;
+    const prBody = [
+        `## Summary`,
+        ``,
+        `Automated PR for issue #${issueNumber}.`,
+        ``,
+        `Fixes #${issueNumber}`,
+        ``,
+        `---`,
+        `🤖 Generated by \`sequant run\``,
+    ].join("\n");
+    const prResult = spawnSync("gh", ["pr", "create", "--title", prTitle, "--body", prBody, "--head", branch], { stdio: "pipe", cwd: worktreePath, timeout: 30000 });
+    if (prResult.status !== 0) {
+        const prError = prResult.stderr?.toString().trim() ?? "Unknown error";
+        // Check if PR already exists (race condition or push-before-PR scenarios)
+        if (prError.includes("already exists")) {
+            const retryView = spawnSync("gh", ["pr", "view", branch, "--json", "number,url"], { stdio: "pipe", cwd: worktreePath, timeout: 15000 });
+            if (retryView.status === 0 && retryView.stdout) {
+                try {
+                    const prInfo = JSON.parse(retryView.stdout.toString());
+                    return {
+                        attempted: true,
+                        success: true,
+                        prNumber: prInfo.number,
+                        prUrl: prInfo.url,
+                    };
+                }
+                catch {
+                    // Fall through to error
+                }
+            }
+        }
+        console.log(chalk.yellow(`    ⚠️  PR creation failed: ${prError}`));
+        return {
+            attempted: true,
+            success: false,
+            error: `gh pr create failed: ${prError}`,
+        };
+    }
+    // Step 4: Extract PR URL from output and get PR details
+    const prOutput = prResult.stdout?.toString().trim() ?? "";
+    const prUrlMatch = prOutput.match(/https:\/\/github\.com\/[^\s]+\/pull\/(\d+)/);
+    if (prUrlMatch) {
+        const prNumber = parseInt(prUrlMatch[1], 10);
+        const prUrl = prUrlMatch[0];
+        console.log(chalk.green(`    ✅ PR #${prNumber} created: ${prUrl}`));
+        return {
+            attempted: true,
+            success: true,
+            prNumber,
+            prUrl,
+        };
+    }
+    // Fallback: try gh pr view to get details
+    const viewResult = spawnSync("gh", ["pr", "view", branch, "--json", "number,url"], { stdio: "pipe", cwd: worktreePath, timeout: 15000 });
+    if (viewResult.status === 0 && viewResult.stdout) {
+        try {
+            const prInfo = JSON.parse(viewResult.stdout.toString());
+            console.log(chalk.green(`    ✅ PR #${prInfo.number} created: ${prInfo.url}`));
+            return {
+                attempted: true,
+                success: true,
+                prNumber: prInfo.number,
+                prUrl: prInfo.url,
+            };
+        }
+        catch {
+            // Fall through
+        }
+    }
+    // PR was created but we couldn't parse the URL
+    console.log(chalk.yellow(`    ⚠️  PR created but could not extract URL from output: ${prOutput}`));
+    return {
+        attempted: true,
+        success: true,
+        error: "PR created but URL extraction failed",
+    };
+}
 /**
  * Natural language prompts for each phase
  * These prompts will invoke the corresponding skills via natural language
@@ -1446,18 +1580,31 @@ export async function runCommand(issues, options) {
     const envConfig = getEnvConfig();
     // Settings provide defaults, env overrides settings, CLI overrides all
     // Note: phases are auto-detected per-issue unless --phases is explicitly set
+    // Commander.js converts --no-X to { X: false }, not { noX: true }.
+    // Normalize these so RunOptions fields (noLog, noMcp, etc.) work correctly.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const cliOpts = options;
+    const normalizedOptions = {
+        ...options,
+        ...(cliOpts.log === false && { noLog: true }),
+        ...(cliOpts.smartTests === false && { noSmartTests: true }),
+        ...(cliOpts.mcp === false && { noMcp: true }),
+        ...(cliOpts.retry === false && { noRetry: true }),
+        ...(cliOpts.rebase === false && { noRebase: true }),
+        ...(cliOpts.pr === false && { noPr: true }),
+    };
     const mergedOptions = {
         // Settings defaults (phases removed - now auto-detected)
-        sequential: options.sequential ?? settings.run.sequential,
-        timeout: options.timeout ?? settings.run.timeout,
-        logPath: options.logPath ?? settings.run.logPath,
-        qualityLoop: options.qualityLoop ?? settings.run.qualityLoop,
-        maxIterations: options.maxIterations ?? settings.run.maxIterations,
-        noSmartTests: options.noSmartTests ?? !settings.run.smartTests,
+        sequential: normalizedOptions.sequential ?? settings.run.sequential,
+        timeout: normalizedOptions.timeout ?? settings.run.timeout,
+        logPath: normalizedOptions.logPath ?? settings.run.logPath,
+        qualityLoop: normalizedOptions.qualityLoop ?? settings.run.qualityLoop,
+        maxIterations: normalizedOptions.maxIterations ?? settings.run.maxIterations,
+        noSmartTests: normalizedOptions.noSmartTests ?? !settings.run.smartTests,
         // Env overrides
         ...envConfig,
         // CLI explicit options override all
-        ...options,
+        ...normalizedOptions,
     };
     // Determine if we should auto-detect phases from labels
     const autoDetectPhases = !options.phases && settings.run.autoDetectPhases;
@@ -1766,6 +1913,10 @@ export async function runCommand(issues, options) {
                 // In chain mode, only the last issue should trigger pre-PR rebase
                 mergedOptions.chain ? i === issueNumbers.length - 1 : undefined);
                 results.push(result);
+                // Record PR info in log before completing issue
+                if (logWriter && result.prNumber && result.prUrl) {
+                    logWriter.setPRInfo(result.prNumber, result.prUrl);
+                }
                 // Complete issue logging
                 if (logWriter) {
                     logWriter.completeIssue();
@@ -1822,6 +1973,10 @@ export async function runCommand(issues, options) {
                 const result = await runIssueWithLogging(issueNumber, config, logWriter, stateManager, issueInfo.title, issueInfo.labels, mergedOptions, worktreeInfo?.path, worktreeInfo?.branch, shutdown, false, // Parallel mode doesn't support chain
                 manifest.packageManager);
                 results.push(result);
+                // Record PR info in log before completing issue
+                if (logWriter && result.prNumber && result.prUrl) {
+                    logWriter.setPRInfo(result.prNumber, result.prUrl);
+                }
                 // Complete issue logging
                 if (logWriter) {
                     logWriter.completeIssue();
@@ -1940,7 +2095,10 @@ export async function runCommand(issues, options) {
                 .map((p) => p.success ? colors.success(p.phase) : colors.error(p.phase))
                 .join(" → ");
             const loopInfo = result.loopTriggered ? colors.warning(" [loop]") : "";
-            console.log(`  ${status} #${result.issueNumber}: ${phases}${loopInfo}${duration}`);
+            const prInfo = result.prUrl
+                ? colors.muted(` → PR #${result.prNumber}`)
+                : "";
+            console.log(`  ${status} #${result.issueNumber}: ${phases}${loopInfo}${prInfo}${duration}`);
         }
         console.log("");
         if (logPath) {
@@ -1987,6 +2145,10 @@ async function executeBatch(issueNumbers, config, logWriter, stateManager, optio
         const result = await runIssueWithLogging(issueNumber, config, logWriter, stateManager, issueInfo.title, issueInfo.labels, options, worktreeInfo?.path, worktreeInfo?.branch, shutdownManager, false, // Batch mode doesn't support chain
         packageManager);
         results.push(result);
+        // Record PR info in log before completing issue
+        if (logWriter && result.prNumber && result.prUrl) {
+            logWriter.setPRInfo(result.prNumber, result.prUrl);
+        }
         // Complete issue logging
         if (logWriter) {
             logWriter.completeIssue();
@@ -2343,11 +2505,36 @@ async function runIssueWithLogging(issueNumber, config, logWriter, stateManager,
     if (shouldRebase) {
         rebaseBeforePR(worktreePath, issueNumber, packageManager, config.verbose);
     }
+    // Create PR after successful QA + rebase (unless --no-pr)
+    let prNumber;
+    let prUrl;
+    const shouldCreatePR = success && worktreePath && branch && !options.noPr;
+    if (shouldCreatePR) {
+        const prResult = createPR(worktreePath, issueNumber, issueTitle, branch, config.verbose, labels);
+        if (prResult.success && prResult.prNumber && prResult.prUrl) {
+            prNumber = prResult.prNumber;
+            prUrl = prResult.prUrl;
+            // Update workflow state with PR info
+            if (stateManager) {
+                try {
+                    await stateManager.updatePRInfo(issueNumber, {
+                        number: prResult.prNumber,
+                        url: prResult.prUrl,
+                    });
+                }
+                catch {
+                    // State tracking errors shouldn't stop execution
+                }
+            }
+        }
+    }
     return {
         issueNumber,
         success,
         phaseResults,
         durationSeconds,
         loopTriggered,
+        prNumber,
+        prUrl,
     };
 }

package/dist/src/lib/merge-check/combined-branch-test.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Combined branch testing (AC-1)
+ *
+ * Creates a temporary branch merging all feature branches from a run batch,
+ * runs npm test && npm run build on the combined state, and reports results.
+ */
+import type { BranchInfo, CheckResult, BranchCheckResult, CheckFinding } from "./types.js";
+/**
+ * Create temp branch, merge all feature branches, run tests and build.
+ *
+ * @param branches - Feature branches to merge
+ * @param repoRoot - Path to the git repository root
+ * @returns CheckResult with combined test findings
+ */
+export declare function runCombinedBranchTest(branches: BranchInfo[], repoRoot: string): CheckResult;
+export declare function buildResult(branchResults: BranchCheckResult[], batchFindings: CheckFinding[], startTime: number): CheckResult;

package/dist/src/lib/merge-check/combined-branch-test.js

@@ -0,0 +1,179 @@
+/**
+ * Combined branch testing (AC-1)
+ *
+ * Creates a temporary branch merging all feature branches from a run batch,
+ * runs npm test && npm run build on the combined state, and reports results.
+ */
+import { spawnSync } from "child_process";
+import { getBranchRef } from "./types.js";
+/**
+ * Run a git command and return the result
+ */
+function git(args, cwd) {
+    const result = spawnSync("git", args, {
+        cwd,
+        stdio: "pipe",
+        encoding: "utf-8",
+    });
+    return {
+        ok: result.status === 0,
+        stdout: result.stdout?.trim() ?? "",
+        stderr: result.stderr?.trim() ?? "",
+    };
+}
+/**
+ * Run npm command and return result
+ */
+function npm(args, cwd) {
+    const result = spawnSync("npm", args, {
+        cwd,
+        stdio: "pipe",
+        encoding: "utf-8",
+        timeout: 120_000, // 2 min timeout for test/build
+    });
+    return {
+        ok: result.status === 0,
+        stdout: result.stdout?.trim() ?? "",
+        stderr: result.stderr?.trim() ?? "",
+    };
+}
+/**
+ * Create temp branch, merge all feature branches, run tests and build.
+ *
+ * @param branches - Feature branches to merge
+ * @param repoRoot - Path to the git repository root
+ * @returns CheckResult with combined test findings
+ */
+export function runCombinedBranchTest(branches, repoRoot) {
+    const startTime = Date.now();
+    const tempBranch = `merge-check/temp-${Date.now()}`;
+    const branchResults = [];
+    const batchFindings = [];
+    const mergeAttempts = [];
+    // Save current branch to restore in finally block
+    const originalBranch = git(["rev-parse", "--abbrev-ref", "HEAD"], repoRoot);
+    try {
+        // Fetch latest from remote
+        git(["fetch", "origin"], repoRoot);
+        // Create temp branch from main
+        const createResult = git(["checkout", "-b", tempBranch, "origin/main"], repoRoot);
+        if (!createResult.ok) {
+            batchFindings.push({
+                check: "combined-branch-test",
+                severity: "error",
+                message: `Failed to create temp branch: ${createResult.stderr}`,
+            });
+            return buildResult(branchResults, batchFindings, startTime);
+        }
+        // Merge each feature branch
+        for (const branch of branches) {
+            const mergeResult = git(["merge", "--no-ff", "--no-edit", getBranchRef(branch)], repoRoot);
+            if (mergeResult.ok) {
+                mergeAttempts.push({
+                    issueNumber: branch.issueNumber,
+                    branch: branch.branch,
+                    success: true,
+                });
+                branchResults.push({
+                    issueNumber: branch.issueNumber,
+                    verdict: "PASS",
+                    findings: [
+                        {
+                            check: "combined-branch-test",
+                            severity: "info",
+                            message: `Branch merged cleanly into combined state`,
+                            issueNumber: branch.issueNumber,
+                        },
+                    ],
+                });
+            }
+            else {
+                // Get conflicting files
+                const conflictResult = git(["diff", "--name-only", "--diff-filter=U"], repoRoot);
+                const conflictFiles = conflictResult.stdout
+                    ? conflictResult.stdout.split("\n")
+                    : [];
+                mergeAttempts.push({
+                    issueNumber: branch.issueNumber,
+                    branch: branch.branch,
+                    success: false,
+                    conflictFiles,
+                    error: mergeResult.stderr,
+                });
+                branchResults.push({
+                    issueNumber: branch.issueNumber,
+                    verdict: "FAIL",
+                    findings: [
+                        {
+                            check: "combined-branch-test",
+                            severity: "error",
+                            message: `Merge conflict with ${conflictFiles.length} file(s): ${conflictFiles.join(", ")}`,
+                            issueNumber: branch.issueNumber,
+                        },
+                    ],
+                });
+                // Abort the failed merge and continue
+                git(["merge", "--abort"], repoRoot);
+            }
+        }
+        // If any merges failed, skip tests but report what we have
+        const failedMerges = mergeAttempts.filter((m) => !m.success);
+        if (failedMerges.length > 0) {
+            batchFindings.push({
+                check: "combined-branch-test",
+                severity: "error",
+                message: `${failedMerges.length}/${branches.length} branches had merge conflicts — skipping test/build`,
+            });
+            return buildResult(branchResults, batchFindings, startTime);
+        }
+        // Run npm test
+        const testResult = npm(["test"], repoRoot);
+        if (testResult.ok) {
+            batchFindings.push({
+                check: "combined-branch-test",
+                severity: "info",
+                message: "npm test passed on combined state",
+            });
+        }
+        else {
+            batchFindings.push({
+                check: "combined-branch-test",
+                severity: "error",
+                message: `npm test failed on combined state: ${testResult.stderr.slice(0, 500)}`,
+            });
+        }
+        // Run npm run build
+        const buildResult2 = npm(["run", "build"], repoRoot);
+        if (buildResult2.ok) {
+            batchFindings.push({
+                check: "combined-branch-test",
+                severity: "info",
+                message: "npm run build passed on combined state",
+            });
+        }
+        else {
+            batchFindings.push({
+                check: "combined-branch-test",
+                severity: "error",
+                message: `npm run build failed on combined state: ${buildResult2.stderr.slice(0, 500)}`,
+            });
+        }
+        return buildResult(branchResults, batchFindings, startTime);
+    }
+    finally {
+        // Clean up: restore original branch and delete temp branch
+        const restoreBranch = originalBranch.ok ? originalBranch.stdout : "main";
+        git(["checkout", restoreBranch], repoRoot);
+        git(["branch", "-D", tempBranch], repoRoot);
+    }
+}
+export function buildResult(branchResults, batchFindings, startTime) {
+    const hasErrors = batchFindings.some((f) => f.severity === "error");
+    return {
+        name: "combined-branch-test",
+        passed: !hasErrors,
+        branchResults,
+        batchFindings,
+        durationMs: Date.now() - startTime,
+    };
+}