@urateam/core 0.1.42 → 0.1.43

package/dist/pipeline/runner.js

@@ -23,7 +23,8 @@ import { promisify } from "node:util";
 const execFileAsync = promisify(execFileCb);
 import { cloneRepo, createWorktree, deleteWorktree, pushBranch, pushBranchForce, choosePushStrategy, rebaseBranch, abortRebase, autoCommitChanges, getAgentCommits, createPRViaCli, mergePRViaCli, getDiffLineCount, getChangedFiles, checkDuplicateBranch, branchName, pruneWorktreesInRepoDirs, gitExecSafe, } from "../repo/git.js";
 import { addPRComment, createGitHubClient, createPR, prHasCommentStartingWith, } from "../repo/github.js";
-import { createMR, buildAuthenticatedUrl, } from "../repo/gitlab.js";
+import { createMR, buildAuthenticatedUrl, addMRComment, mergeMRWhenPipelineSucceeds, } from "../repo/gitlab.js";
+import { buildBitbucketAuthenticatedUrl, createBitbucketPR, addBitbucketPRComment, mergeBitbucketPR, parseBitbucketUrl, } from "../repo/bitbucket.js";
 import { parseRepoUrl, parseGitLabUrl } from "../repo/config.js";
 import { detectTechStack } from "../repo/tech-stack.js";
 import { shouldUseDevcontainer, devcontainerUp, devcontainerDown, } from "../repo/devcontainer.js";
@@ -65,8 +66,11 @@ export class PipelineRunner {
     repoCloneDir;
     githubConfig;
     gitlabConfig;
+    bitbucketConfig;
     lockAdapter;
     prLockTimeoutMs;
+    /** Memoised Octokit promise — created once per PipelineRunner instance. */
+    _octokitPromise;
     constructor(config) {
         this.db = config.db;
         this.notifier = config.notifier;
@@ -76,9 +80,24 @@ export class PipelineRunner {
         this.repoCloneDir = config.repoCloneDir ?? join(homedir(), "work", "repos");
         this.githubConfig = config.github;
         this.gitlabConfig = config.gitlab;
+        this.bitbucketConfig = config.bitbucket;
         this.lockAdapter = createBranchLockAdapter(config.db);
         this.prLockTimeoutMs = config.prLockTimeoutMs ?? 120_000;
     }
+    /**
+     * Lazy-memoised Octokit instance — created at most once per PipelineRunner.
+     * Multiple concurrent callers share the same Promise so construction happens
+     * exactly once even under parallel await.
+     */
+    getOctokit() {
+        if (!this._octokitPromise) {
+            if (!this.githubConfig)
+                throw new Error("githubConfig required for Octokit");
+            this._octokitPromise = createGitHubClient(this.githubConfig);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        return this._octokitPromise;
+    }
     async start(issue, pipelineKey, pipelineConfig, repoConfig, sanitizedIssue, linearTeamId = null) {
         log.info({ issueId: issue.identifier, pipeline: pipelineKey }, "start() called");
         if (this.activeRuns.has(issue.identifier)) {
@@ -413,6 +432,7 @@ export class PipelineRunner {
             agentRunDir: this.agentRunDir,
             githubConfig: this.githubConfig,
             gitlabConfig: this.gitlabConfig,
+            bitbucketConfig: this.bitbucketConfig,
             pushQueue: this.pushQueue,
             lockAdapter: this.lockAdapter,
             prLockTimeoutMs: this.prLockTimeoutMs,
@@ -498,10 +518,12 @@ export class PipelineRunner {
                 // Fresh start — clone repository, create worktree, run setup.
                 // ---------------------------------------------------------------
                 const repoDir = `${this.repoCloneDir}/${sanitizedIssue.slug}`;
-                // Inject credentials for GitLab private repos
+                // Inject credentials for GitLab / Bitbucket private repos
                 const cloneUrl = (repoConfig.provider === "gitlab" && this.gitlabConfig)
                     ? buildAuthenticatedUrl(repoConfig.url, this.gitlabConfig)
-                    : repoConfig.url;
+                    : (repoConfig.provider === "bitbucket" && this.bitbucketConfig)
+                        ? buildBitbucketAuthenticatedUrl(repoConfig.url, this.bitbucketConfig)
+                        : repoConfig.url;
                 const logUrl = cloneUrl.replace(/:\/\/[^@]+@/, "://[redacted]@");
                 runLog.info({ repoUrl: logUrl, repoDir }, "cloning repository");
                 await cloneRepo(cloneUrl, repoDir);
@@ -1509,6 +1531,27 @@ export class PipelineRunner {
             // via a DB advisory lock (Postgres) so they can't race on PR creation for
             // the same branch.  If the lock cannot be acquired within prLockTimeoutMs,
             // the pipeline fails with a LockTimeoutError.
+            // Parse the repo URL once here — repoConfig.url is constant for the
+            // lifetime of this pipeline run. All GitHub/gh-CLI call sites below
+            // consume parsedRepoUrl instead of re-parsing the same string.
+            // Null on parse failure so the gh-CLI fallback path (which tolerates
+            // a missing owner) keeps working; GitHub-App paths use
+            // requireParsedRepoUrl() below to surface a clear error instead of
+            // crashing on a non-null assertion.
+            const parsedRepoUrl = (() => {
+                try {
+                    return parseRepoUrl(repoConfig.url);
+                }
+                catch {
+                    return null;
+                }
+            })();
+            const requireParsedRepoUrl = () => {
+                if (!parsedRepoUrl) {
+                    throw new Error(`PipelineRunner: failed to parse repo URL '${repoConfig.url}' — cannot interact with GitHub API`);
+                }
+                return parsedRepoUrl;
+            };
             let prUrl = "";
             let autoMerged = false;
             await this.pushQueue.enqueue(async () => {
@@ -1598,6 +1641,7 @@ export class PipelineRunner {
                         agentCommits,
                     });
                     const isGitLab = repoConfig.provider === "gitlab";
+                    const isBitbucket = repoConfig.provider === "bitbucket";
                     // Mandatory reviewer request (enterprise feature 4.6). Only non-null
                     // when the org-policy feature is licensed and the pipeline config
                     // specifies mandatoryReviewers.
@@ -1624,11 +1668,31 @@ export class PipelineRunner {
                             runLog.error({ err: mrError }, "MR creation via GitLab API failed");
                         }
                     }
-                    else if (!isGitLab && this.githubConfig) {
+                    else if (isBitbucket && this.bitbucketConfig) {
+                        // Bitbucket — create PR via REST API
+                        try {
+                            const { workspace, repoSlug } = parseBitbucketUrl(repoConfig.url);
+                            prUrl = await createBitbucketPR(this.bitbucketConfig, {
+                                workspace,
+                                repoSlug,
+                                sourceBranch: branch,
+                                targetBranch: repoConfig.defaultBranch,
+                                title: sanitizedIssue.title,
+                                description: prBody,
+                                draft: shouldDraft,
+                            });
+                            run.prUrl = prUrl;
+                            runLog.info({ prUrl }, "PR created via Bitbucket API");
+                        }
+                        catch (prError) {
+                            runLog.error({ err: prError }, "PR creation via Bitbucket API failed");
+                        }
+                    }
+                    else if (!isGitLab && !isBitbucket && this.githubConfig) {
                         // GitHub App — use Octokit API
                         try {
-                            const { owner, repo } = parseRepoUrl(repoConfig.url);
-                            const octokit = await createGitHubClient(this.githubConfig);
+                            const { owner, repo } = requireParsedRepoUrl();
+                            const octokit = await this.getOctokit();
                             prUrl = await createPR(octokit, {
                                 owner,
                                 repo,
@@ -1646,17 +1710,10 @@ export class PipelineRunner {
                             runLog.error({ err: prError }, "PR creation via GitHub App failed");
                         }
                     }
-                    else {
+                    else if (!isGitLab && !isBitbucket) {
                         // No provider-specific config — use gh CLI
                         runLog.info("creating PR via gh CLI");
-                        const { owner: ghOwner } = (() => {
-                            try {
-                                return parseRepoUrl(repoConfig.url);
-                            }
-                            catch {
-                                return { owner: undefined };
-                            }
-                        })();
+                        const ghOwner = parsedRepoUrl?.owner;
                         prUrl = await createPRViaCli({
                             worktreePath: wtPath,
                             branch,
@@ -1684,10 +1741,11 @@ export class PipelineRunner {
                     }
                     // BEC-134: Post fanout (per-model) review comments on the PR. Best-effort —
                     // failures never block the pipeline. Requires the GitHub App for Octokit
-                    // access; the gh-CLI/GitLab paths skip this (parity gap accepted for v1).
+                    // access; the gh-CLI/GitLab/Bitbucket paths skip this (parity gap accepted for v1).
                     if (prUrl &&
                         pendingFanoutRuns.length > 0 &&
                         !isGitLab &&
+                        !isBitbucket &&
                         this.githubConfig) {
                         const fanoutPrNumberMatch = prUrl.match(/\/pull\/(\d+)/);
                         const fanoutPrNumber = fanoutPrNumberMatch
@@ -1695,8 +1753,8 @@ export class PipelineRunner {
                             : null;
                         if (fanoutPrNumber !== null) {
                             try {
-                                const { owner: fanoutOwner, repo: fanoutRepo } = parseRepoUrl(repoConfig.url);
-                                const fanoutOctokit = await createGitHubClient(this.githubConfig);
+                                const { owner: fanoutOwner, repo: fanoutRepo } = requireParsedRepoUrl();
+                                const fanoutOctokit = await this.getOctokit();
                                 const fanoutResult = await postFanoutCommentsToPR(fanoutOctokit, fanoutOwner, fanoutRepo, fanoutPrNumber, pendingFanoutRuns);
                                 runLog.info({
                                     prNumber: fanoutPrNumber,
@@ -1782,10 +1840,9 @@ export class PipelineRunner {
                             : `${ralphGaps.length} unmet acceptance criteria`;
                         await this.notifier.onHumanReviewNeeded?.(run, prUrl, `Draft PR created — ${ralphSummary}, ${unresolvedBlockingFindings.length} blocking findings`);
                     }
-                    // 6. Auto-merge (skip drafts, unresolved conflicts, or GitLab)
+                    // 6. Auto-merge (skip drafts, unresolved conflicts)
                     const maxLines = config.autoMergeMaxLines ?? 200;
-                    const isGitLabRepo = repoConfig.provider === "gitlab";
-                    if (config.autoMerge && prUrl && !rebaseConflict && !isGitLabRepo && !shouldDraft) {
+                    if (config.autoMerge && prUrl && !rebaseConflict && !shouldDraft) {
                         const diffLines = await getDiffLineCount(wtPath, repoConfig.defaultBranch);
                         const lastHandoff = handoff;
                         const hasBlockingFindings = lastHandoff?.context?.reviewFindings?.some((f) => f.severity === "blocking");
@@ -1815,7 +1872,7 @@ export class PipelineRunner {
                         // Known limitation: the reviewer check requires an Octokit API
                         // client (to call pulls.listReviews / teams.listMembersInOrg), so
                         // it only fires when the GitHub App is configured. The `gh` CLI
-                        // fallback and GitLab paths skip this check — documented in the
+                        // fallback and GitLab/Bitbucket paths skip this check — documented in the
                         // plan as acceptable because production deployments use the App.
                         if (shouldMerge && isFeatureLicensed("org-policy")) {
                             const policyReviewerRequest = buildReviewerRequest(config.policy);
@@ -1833,7 +1890,7 @@ export class PipelineRunner {
                                         : undefined;
                                     if (owner && repo && prNumber) {
                                         try {
-                                            const octokit = await createGitHubClient(this.githubConfig);
+                                            const octokit = await this.getOctokit();
                                             const check = await verifyApprovalsReceived(octokit, owner, repo, prNumber, policyReviewerRequest);
                                             if (!check.satisfied) {
                                                 shouldMerge = false;
@@ -1855,16 +1912,81 @@ export class PipelineRunner {
                             }
                         }
                         if (shouldMerge) {
-                            runLog.info({ diffLines, maxLines }, "auto-merge eligible, merging PR");
-                            autoMerged = await mergePRViaCli(wtPath, branch);
-                            if (autoMerged) {
-                                autoMergeReason = "PR auto-merged successfully";
-                                runLog.info({ prUrl }, "PR auto-merged");
+                            runLog.info({ diffLines, maxLines, provider: repoConfig.provider }, "auto-merge eligible, merging PR");
+                            if (isGitLab && this.gitlabConfig) {
+                                // GitLab: use merge_when_pipeline_succeeds API
+                                try {
+                                    const { projectPath } = parseGitLabUrl(repoConfig.url);
+                                    // Extract MR IID from URL: .../-/merge_requests/42
+                                    const mrIidMatch = prUrl.match(/\/merge_requests\/(\d+)/);
+                                    const mrIid = mrIidMatch ? parseInt(mrIidMatch[1], 10) : null;
+                                    if (mrIid !== null) {
+                                        autoMerged = await mergeMRWhenPipelineSucceeds(this.gitlabConfig, projectPath, mrIid);
+                                        if (autoMerged) {
+                                            autoMergeReason = "PR auto-merged via GitLab merge_when_pipeline_succeeds";
+                                            runLog.info({ prUrl }, "GitLab MR queued for merge when pipeline succeeds");
+                                        }
+                                        else {
+                                            autoMergeReason = "GitLab merge_when_pipeline_succeeds API call failed";
+                                            runLog.warn("GitLab auto-merge failed, sending human review alert");
+                                            await this.notifier.onHumanReviewNeeded?.(run, prUrl, "GitLab auto-merge failed — please merge manually");
+                                        }
+                                    }
+                                    else {
+                                        autoMergeReason = "Could not parse MR IID from URL";
+                                        runLog.warn({ prUrl }, "GitLab auto-merge: could not parse MR IID");
+                                        await this.notifier.onHumanReviewNeeded?.(run, prUrl, "GitLab auto-merge failed — could not determine MR ID");
+                                    }
+                                }
+                                catch (err) {
+                                    autoMergeReason = "GitLab auto-merge threw an error";
+                                    runLog.error({ err }, "GitLab auto-merge error");
+                                    await this.notifier.onHumanReviewNeeded?.(run, prUrl, "GitLab auto-merge failed — please merge manually");
+                                }
+                            }
+                            else if (isBitbucket && this.bitbucketConfig) {
+                                // Bitbucket: use PR merge API
+                                try {
+                                    const { workspace, repoSlug } = parseBitbucketUrl(repoConfig.url);
+                                    // Extract PR ID from URL: .../pull-requests/42
+                                    const prIdMatch = prUrl.match(/\/pull-requests\/(\d+)/);
+                                    const prId = prIdMatch ? parseInt(prIdMatch[1], 10) : null;
+                                    if (prId !== null) {
+                                        autoMerged = await mergeBitbucketPR(this.bitbucketConfig, workspace, repoSlug, prId);
+                                        if (autoMerged) {
+                                            autoMergeReason = "PR auto-merged via Bitbucket API";
+                                            runLog.info({ prUrl }, "Bitbucket PR merged");
+                                        }
+                                        else {
+                                            autoMergeReason = "Bitbucket merge API call failed";
+                                            runLog.warn("Bitbucket auto-merge failed, sending human review alert");
+                                            await this.notifier.onHumanReviewNeeded?.(run, prUrl, "Bitbucket auto-merge failed — please merge manually");
+                                        }
+                                    }
+                                    else {
+                                        autoMergeReason = "Could not parse PR ID from Bitbucket URL";
+                                        runLog.warn({ prUrl }, "Bitbucket auto-merge: could not parse PR ID");
+                                        await this.notifier.onHumanReviewNeeded?.(run, prUrl, "Bitbucket auto-merge failed — could not determine PR ID");
+                                    }
+                                }
+                                catch (err) {
+                                    autoMergeReason = "Bitbucket auto-merge threw an error";
+                                    runLog.error({ err }, "Bitbucket auto-merge error");
+                                    await this.notifier.onHumanReviewNeeded?.(run, prUrl, "Bitbucket auto-merge failed — please merge manually");
+                                }
                             }
                             else {
-                                autoMergeReason = "Auto-merge command failed";
-                                runLog.warn("auto-merge failed, sending human review alert");
-                                await this.notifier.onHumanReviewNeeded?.(run, prUrl, "Auto-merge failed — please merge manually");
+                                // GitHub / gh CLI fallback
+                                autoMerged = await mergePRViaCli(wtPath, branch);
+                                if (autoMerged) {
+                                    autoMergeReason = "PR auto-merged successfully";
+                                    runLog.info({ prUrl }, "PR auto-merged");
+                                }
+                                else {
+                                    autoMergeReason = "Auto-merge command failed";
+                                    runLog.warn("auto-merge failed, sending human review alert");
+                                    await this.notifier.onHumanReviewNeeded?.(run, prUrl, "Auto-merge failed — please merge manually");
+                                }
                             }
                         }
                         else {
@@ -1914,65 +2036,89 @@ export class PipelineRunner {
             });
             // BEC-175: optional per-PR cost summary comment. Opt-in via
             // URATEAM_PR_COST_SUMMARY=true. Best-effort — failures never block
-            // pipeline completion.
+            // pipeline completion. Supported on GitHub, GitLab, and Bitbucket.
+            // BEC-206: provider booleans must be local to this block — the
+            // declarations inside the push queue scope are not visible here.
+            const isGitLab = repoConfig.provider === "gitlab";
+            const isBitbucket = repoConfig.provider === "bitbucket";
             if (process.env.URATEAM_PR_COST_SUMMARY === "true" &&
-                prUrl &&
-                repoConfig.provider !== "gitlab" &&
-                this.githubConfig) {
+                prUrl) {
                 try {
-                    const summaryPrMatch = prUrl.match(/\/pull\/(\d+)/);
-                    const summaryPrNumber = summaryPrMatch
-                        ? parseInt(summaryPrMatch[1], 10)
-                        : null;
-                    if (summaryPrNumber !== null) {
-                        // Fetch stage runs first; reviewModelRuns query depends on the
-                        // resulting stageIds so the two queries are necessarily sequential.
-                        const stages = await this.db
+                    // Build cost body regardless of provider
+                    const stages = await this.db
+                        .select()
+                        .from(stageRuns)
+                        .where(eq(stageRuns.pipelineRunId, runId));
+                    const stageIds = stages.map((s) => s.id);
+                    const modelRows = stageIds.length > 0
+                        ? await this.db
                             .select()
-                            .from(stageRuns)
-                            .where(eq(stageRuns.pipelineRunId, runId));
-                        const stageIds = stages.map((s) => s.id);
-                        const modelRows = stageIds.length > 0
-                            ? await this.db
-                                .select()
-                                .from(reviewModelRuns)
-                                .where(inArray(reviewModelRuns.stageRunId, stageIds))
-                            : [];
-                        const modelsByStage = new Map();
-                        for (const mr of modelRows) {
-                            const arr = modelsByStage.get(mr.stageRunId) ?? [];
-                            arr.push({
-                                modelId: mr.modelId,
-                                inputTokens: mr.inputTokens,
-                                outputTokens: mr.outputTokens,
-                            });
-                            modelsByStage.set(mr.stageRunId, arr);
-                        }
-                        const breakdown = stages.map((s) => ({
-                            stage: s.stage,
-                            inputTokens: s.inputTokens,
-                            outputTokens: s.outputTokens,
-                            cacheCreationInputTokens: s.cacheCreationInputTokens ?? 0,
-                            cacheReadInputTokens: s.cacheReadInputTokens ?? 0,
-                            modelRuns: modelsByStage.get(s.id),
-                        }));
-                        const body = formatPRCostSummary(breakdown, run.pipelineKey, {
-                            pipelineConfigs: { [run.pipelineKey]: config },
+                            .from(reviewModelRuns)
+                            .where(inArray(reviewModelRuns.stageRunId, stageIds))
+                        : [];
+                    const modelsByStage = new Map();
+                    for (const mr of modelRows) {
+                        const arr = modelsByStage.get(mr.stageRunId) ?? [];
+                        arr.push({
+                            modelId: mr.modelId,
+                            inputTokens: mr.inputTokens,
+                            outputTokens: mr.outputTokens,
                         });
-                        if (body) {
-                            const { owner: summaryOwner, repo: summaryRepo } = parseRepoUrl(repoConfig.url);
-                            const summaryOctokit = await createGitHubClient(this.githubConfig);
-                            // Dedup: skip when a prior pipeline run on this PR already
-                            // posted a cost summary. We use the markdown header as the
-                            // sentinel so the check survives any token/dollar diff between
-                            // runs.
-                            const alreadyPosted = await prHasCommentStartingWith(summaryOctokit, summaryOwner, summaryRepo, summaryPrNumber, "🤖 **Pipeline cost summary**");
-                            if (alreadyPosted) {
-                                runLog.info({ prNumber: summaryPrNumber }, "BEC-175: cost summary already exists on PR — skipping");
+                        modelsByStage.set(mr.stageRunId, arr);
+                    }
+                    const breakdown = stages.map((s) => ({
+                        stage: s.stage,
+                        inputTokens: s.inputTokens,
+                        outputTokens: s.outputTokens,
+                        cacheCreationInputTokens: s.cacheCreationInputTokens ?? 0,
+                        cacheReadInputTokens: s.cacheReadInputTokens ?? 0,
+                        modelRuns: modelsByStage.get(s.id),
+                    }));
+                    const costBody = formatPRCostSummary(breakdown, run.pipelineKey, {
+                        pipelineConfigs: { [run.pipelineKey]: config },
+                    });
+                    if (costBody) {
+                        if (isGitLab && this.gitlabConfig) {
+                            // GitLab: post via REST API
+                            const { projectPath } = parseGitLabUrl(repoConfig.url);
+                            const mrIidMatch = prUrl.match(/\/merge_requests\/(\d+)/);
+                            const mrIid = mrIidMatch ? parseInt(mrIidMatch[1], 10) : null;
+                            if (mrIid !== null) {
+                                await addMRComment(this.gitlabConfig, projectPath, mrIid, costBody);
+                                runLog.info({ mrIid }, "BEC-175: posted GitLab MR cost summary");
                             }
-                            else {
-                                await addPRComment(summaryOctokit, summaryOwner, summaryRepo, summaryPrNumber, body);
-                                runLog.info({ prNumber: summaryPrNumber }, "BEC-175: posted PR cost summary");
+                        }
+                        else if (isBitbucket && this.bitbucketConfig) {
+                            // Bitbucket: post via REST API
+                            const { workspace, repoSlug } = parseBitbucketUrl(repoConfig.url);
+                            const prIdMatch = prUrl.match(/\/pull-requests\/(\d+)/);
+                            const prId = prIdMatch ? parseInt(prIdMatch[1], 10) : null;
+                            if (prId !== null) {
+                                await addBitbucketPRComment(this.bitbucketConfig, workspace, repoSlug, prId, costBody);
+                                runLog.info({ prId }, "BEC-175: posted Bitbucket PR cost summary");
+                            }
+                        }
+                        else if (this.githubConfig) {
+                            // GitHub: use Octokit with dedup check
+                            const summaryPrMatch = prUrl.match(/\/pull\/(\d+)/);
+                            const summaryPrNumber = summaryPrMatch
+                                ? parseInt(summaryPrMatch[1], 10)
+                                : null;
+                            if (summaryPrNumber !== null) {
+                                const { owner: summaryOwner, repo: summaryRepo } = requireParsedRepoUrl();
+                                const summaryOctokit = await this.getOctokit();
+                                // Dedup: skip when a prior pipeline run on this PR already
+                                // posted a cost summary. We use the markdown header as the
+                                // sentinel so the check survives any token/dollar diff between
+                                // runs.
+                                const alreadyPosted = await prHasCommentStartingWith(summaryOctokit, summaryOwner, summaryRepo, summaryPrNumber, "🤖 **Pipeline cost summary**");
+                                if (alreadyPosted) {
+                                    runLog.info({ prNumber: summaryPrNumber }, "BEC-175: cost summary already exists on PR — skipping");
+                                }
+                                else {
+                                    await addPRComment(summaryOctokit, summaryOwner, summaryRepo, summaryPrNumber, costBody);
+                                    runLog.info({ prNumber: summaryPrNumber }, "BEC-175: posted PR cost summary");
+                                }
                             }
                         }
                     }
@@ -1983,36 +2129,90 @@ export class PipelineRunner {
             }
             // PR change-summary comment for review-feedback runs. Always-on (no env
             // flag) — a review-feedback run only exists because a human asked for
-            // changes, so silent shipping is a bug.
-            if (run.runType === "review-feedback" &&
-                prUrl &&
-                repoConfig.provider !== "gitlab" &&
-                this.githubConfig) {
+            // changes, so silent shipping is a bug. Supported on all providers.
+            if (run.runType === "review-feedback" && prUrl) {
                 try {
-                    const summaryPrMatch = prUrl.match(/\/pull\/(\d+)/);
-                    const summaryPrNumber = summaryPrMatch
-                        ? parseInt(summaryPrMatch[1], 10)
-                        : null;
-                    const { owner: csOwner, repo: csRepo } = parseRepoUrl(repoConfig.url);
-                    const csOctokit = await createGitHubClient(this.githubConfig);
-                    await maybePostChangeSummary({
-                        run: {
-                            id: run.id,
-                            runType: run.runType,
-                            prUrl: run.prUrl,
-                            feedbackContext: run.feedbackContext ?? null,
-                            totalInputTokens: run.totalInputTokens,
-                            totalOutputTokens: run.totalOutputTokens,
-                        },
-                        handoff: handoff ?? null,
-                        prNumber: summaryPrNumber,
-                        owner: csOwner,
-                        repo: csRepo,
-                        octokit: csOctokit,
-                        postPRComment: addPRComment,
-                        dashboardBaseUrl: process.env.URATEAM_DASHBOARD_URL ?? "",
-                        logger: runLog,
-                    });
+                    if (isGitLab && this.gitlabConfig) {
+                        // GitLab: build change summary and post via addMRComment
+                        const { projectPath } = parseGitLabUrl(repoConfig.url);
+                        const mrIidMatch = prUrl.match(/\/merge_requests\/(\d+)/);
+                        const mrIid = mrIidMatch ? parseInt(mrIidMatch[1], 10) : null;
+                        if (mrIid !== null && handoff) {
+                            const { renderChangeSummary } = await import("./pr-change-summary.js");
+                            let triggeringComments = [];
+                            if (run.feedbackContext) {
+                                try {
+                                    const parsed = JSON.parse(run.feedbackContext);
+                                    if (Array.isArray(parsed))
+                                        triggeringComments = parsed;
+                                }
+                                catch { /* ignore */ }
+                            }
+                            const csBody = renderChangeSummary({
+                                handoff,
+                                run: { id: run.id, totalInputTokens: run.totalInputTokens, totalOutputTokens: run.totalOutputTokens },
+                                triggeringComments,
+                                dashboardBaseUrl: process.env.URATEAM_DASHBOARD_URL ?? "",
+                                prUrl,
+                            });
+                            await addMRComment(this.gitlabConfig, projectPath, mrIid, csBody);
+                            runLog.info({ mrIid }, "posted GitLab MR change summary for review-feedback run");
+                        }
+                    }
+                    else if (isBitbucket && this.bitbucketConfig) {
+                        // Bitbucket: build change summary and post via addBitbucketPRComment
+                        const { workspace, repoSlug } = parseBitbucketUrl(repoConfig.url);
+                        const prIdMatch = prUrl.match(/\/pull-requests\/(\d+)/);
+                        const prId = prIdMatch ? parseInt(prIdMatch[1], 10) : null;
+                        if (prId !== null && handoff) {
+                            const { renderChangeSummary } = await import("./pr-change-summary.js");
+                            let triggeringComments = [];
+                            if (run.feedbackContext) {
+                                try {
+                                    const parsed = JSON.parse(run.feedbackContext);
+                                    if (Array.isArray(parsed))
+                                        triggeringComments = parsed;
+                                }
+                                catch { /* ignore */ }
+                            }
+                            const csBody = renderChangeSummary({
+                                handoff,
+                                run: { id: run.id, totalInputTokens: run.totalInputTokens, totalOutputTokens: run.totalOutputTokens },
+                                triggeringComments,
+                                dashboardBaseUrl: process.env.URATEAM_DASHBOARD_URL ?? "",
+                                prUrl,
+                            });
+                            await addBitbucketPRComment(this.bitbucketConfig, workspace, repoSlug, prId, csBody);
+                            runLog.info({ prId }, "posted Bitbucket PR change summary for review-feedback run");
+                        }
+                    }
+                    else {
+                        // GitHub: use existing maybePostChangeSummary helper
+                        const summaryPrMatch = prUrl.match(/\/pull\/(\d+)/);
+                        const summaryPrNumber = summaryPrMatch
+                            ? parseInt(summaryPrMatch[1], 10)
+                            : null;
+                        const { owner: csOwner, repo: csRepo } = requireParsedRepoUrl();
+                        const csOctokit = await this.getOctokit();
+                        await maybePostChangeSummary({
+                            run: {
+                                id: run.id,
+                                runType: run.runType,
+                                prUrl: run.prUrl,
+                                feedbackContext: run.feedbackContext ?? null,
+                                totalInputTokens: run.totalInputTokens,
+                                totalOutputTokens: run.totalOutputTokens,
+                            },
+                            handoff: handoff ?? null,
+                            prNumber: summaryPrNumber,
+                            owner: csOwner,
+                            repo: csRepo,
+                            octokit: csOctokit,
+                            postPRComment: addPRComment,
+                            dashboardBaseUrl: process.env.URATEAM_DASHBOARD_URL ?? "",
+                            logger: runLog,
+                        });
+                    }
                 }
                 catch (err) {
                     runLog.warn({ err: err instanceof Error ? err.message : String(err) }, "PR change summary post failed (non-fatal)");