@urateam/core 0.1.31 → 0.1.32

package/dist/pipeline/runner.js

@@ -7,6 +7,8 @@ import { checkRequirements, buildRalphContext } from "../executor/ralph.js";
 import { computeEffectiveRalphIterations } from "./runner-ralph-helpers.js";
 import { checkTestQuality } from "../executor/test-quality.js";
 import { buildDeepReviewContext } from "../executor/deep-review.js";
+import { getStopSignal, requestStop, clearStopSignal } from "./control-signals.js";
+import { setPmPaused } from "../pm/pause-state.js";
 import { runReviewProviders } from "./review-providers-runner.js";
 import { postFanoutCommentsToPR } from "../executor/review/post-fanout-comments.js";
 import { extractHandoff } from "../executor/extract-handoff.js";
@@ -19,8 +21,8 @@ import { homedir } from "node:os";
 import { execFile as execFileCb } from "node:child_process";
 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, createWorktreeFromRemote, pruneWorktreesInRepoDirs, } from "../repo/git.js";
-import { addPRComment, createGitHubClient, createPR, prHasCommentStartingWith, rerequestPRReview, } from "../repo/github.js";
+import { cloneRepo, createWorktree, deleteWorktree, pushBranch, pushBranchForce, choosePushStrategy, rebaseBranch, abortRebase, autoCommitChanges, getAgentCommits, createPRViaCli, mergePRViaCli, getDiffLineCount, getChangedFiles, checkDuplicateBranch, branchName, pruneWorktreesInRepoDirs, } from "../repo/git.js";
+import { addPRComment, createGitHubClient, createPR, prHasCommentStartingWith, } from "../repo/github.js";
 import { createMR, buildAuthenticatedUrl, } from "../repo/gitlab.js";
 import { parseRepoUrl, parseGitLabUrl } from "../repo/config.js";
 import { detectTechStack } from "../repo/tech-stack.js";
@@ -36,35 +38,13 @@ import { evaluatePolicyGates } from "../policy/evaluate.js";
 import { buildReviewerRequest, verifyApprovalsReceived } from "../policy/index.js";
 import { logAuditEvent, policyReviewersRequestedEvent, reviewFanoutFallbackUsedEvent } from "../audit/index.js";
 import { matchesAnyPattern } from "../util/glob.js";
+import { startFeedbackPipeline, } from "./feedback-pipeline.js";
+// Re-export from extracted module so existing callers (including tests) still
+// find buildReviewFeedbackContext at pipeline/runner.js without changing their
+// import paths.
+export { buildReviewFeedbackContext } from "./feedback-pipeline.js";
 // Module-level logger (no runId yet — used for pre-run messages)
 const log = createLogger({ component: "PipelineRunner" });
-/**
- * Map webhook-shaped `ReviewFeedbackComment[]` (the wire format we receive
- * from GitHub) into the `ReviewFeedbackContext` that the implement template
- * expects when handling PR review feedback.
- *
- * Routes the implement stage into the dedicated review-feedback prompt path
- * (templates.ts:233-253) — "address review comments on existing branch, push
- * to same branch, do NOT create a new PR" — instead of falling through to
- * the standard "create branch and implement issue from scratch" prompt.
- *
- * `createdAt` is not captured by the GitHub webhook handler today, so the
- * mapped comments use an empty string. The template only renders this for
- * display; an empty value is harmless.
- */
-export function buildReviewFeedbackContext(prUrl, prBranch, comments) {
-    return {
-        prUrl,
-        prBranch,
-        comments: comments.map((c) => ({
-            author: c.author,
-            body: c.body,
-            file: c.filePath,
-            line: c.lineNumber,
-            createdAt: "",
-        })),
-    };
-}
 export class PipelineRunner {
     queue;
     /** Push queue: concurrency=1 serialises push+PR creation within this process.
@@ -330,6 +310,83 @@ export class PipelineRunner {
             .where(eq(pipelineRuns.id, runId));
         this.activeRuns.delete(issueId);
     }
+    /**
+     * Operator-initiated stop for a single run, addressed by runId.
+     *
+     * - `"cancel"` aborts the active Agent SDK stream immediately. The current
+     *   stage exits with `status: "cancelled"`; the pipeline marks the run
+     *   `cancelled` and returns without creating a PR.
+     * - `"graceful"` lets the current stage complete, then skips remaining
+     *   stages. Slower than cancel but leaves the worktree consistent.
+     *
+     * Idempotent. Returns the issueId resolved from the active map (or null if
+     * the runId isn't currently active). The caller is responsible for emitting
+     * the audit event since it knows the actor.
+     */
+    requestStop(runId, mode) {
+        let issueId = null;
+        for (const [iss, rid] of this.activeRuns) {
+            if (rid === runId) {
+                issueId = iss;
+                break;
+            }
+        }
+        const effective = requestStop(runId, mode);
+        return { issueId, mode: effective };
+    }
+    /**
+     * Halt the whole container's autonomous work:
+     *  1. Pauses the PM Agent (BEC-170 mechanism) so no new runs get promoted.
+     *  2. Sends a `"cancel"` signal to every active pipeline + feedback run.
+     *
+     * Returns the set of run ids that were cancelled — the caller emits the
+     * audit event. Reversible: PM Agent can be unpaused via `/pm resume` and
+     * individual runs can be re-triggered via the retry button. Cancelled runs
+     * stay cancelled.
+     */
+    haltAll() {
+        setPmPaused(true);
+        const cancelled = new Set();
+        for (const runId of this.activeRuns.values()) {
+            requestStop(runId, "cancel");
+            cancelled.add(runId);
+        }
+        for (const runId of this.activeFeedbackRuns.values()) {
+            requestStop(runId, "cancel");
+            cancelled.add(runId);
+        }
+        log.info({ count: cancelled.size, runIds: [...cancelled] }, "haltAll: PM paused and cancel signals sent to active runs");
+        return { cancelledRunIds: [...cancelled] };
+    }
+    /**
+     * Mark a run as cancelled in the DB and clean up bookkeeping. Shared by the
+     * pre-stage graceful path and the mid-stream cancel path.
+     *
+     * For feedback-pipeline runs, pass `feedbackPrUrl` so the per-PR rate-limit
+     * slot is freed immediately rather than waiting on the queue's `finally`
+     * block. The queue's `finally` still fires (idempotent — Map.delete on a
+     * missing key is a no-op), this just shortens the window during which a new
+     * feedback comment on the same PR is rejected as "already active".
+     */
+    markRunCancelled(db, runId, run, mode, feedbackPrUrl) {
+        return this.markRunCancelledImpl(db, runId, run, mode, feedbackPrUrl);
+    }
+    async markRunCancelledImpl(db, runId, run, mode, feedbackPrUrl) {
+        await removeActiveWork(db, runId);
+        await db
+            .update(pipelineRuns)
+            .set({
+            status: "cancelled",
+            errorMessage: `cancelled by operator (${mode})`,
+            completedAt: new Date(),
+        })
+            .where(eq(pipelineRuns.id, runId));
+        run.status = "cancelled";
+        this.activeRuns.delete(run.issueId);
+        if (feedbackPrUrl)
+            this.activeFeedbackRuns.delete(feedbackPrUrl);
+        clearStopSignal(runId);
+    }
     isActive(issueId) {
         return this.activeRuns.has(issueId);
     }
@@ -340,77 +397,31 @@ export class PipelineRunner {
     /**
      * Start a review-feedback pipeline run triggered by a PR review comment.
      *
-     * Unlike start(), this method:
-     *  - Does NOT create a new branch — it checks out the existing PR branch.
-     *  - Skips triage and reproduce stages, entering directly at implement.
-     *  - Does NOT create a new PR — it pushes to the same branch.
-     *  - Optionally re-requests review after pushing.
+     * Thin wrapper — all orchestration logic (rate-limiting, DB insert, queue
+     * management) and execution are delegated to feedback-pipeline.ts.
+     * See startFeedbackPipeline() for full documentation.
      */
     async startFeedback(params) {
-        const { issue, pipelineKey, pipelineConfig, repoConfig, sanitizedIssue, branch, prUrl, prNumber, parentRunId, feedbackComments, rerequestReview, } = params;
-        log.info({ issueId: issue.identifier, pipeline: pipelineKey, prUrl }, "startFeedback() called");
-        // Rate-limit: one feedback run per PR at a time
-        if (this.activeFeedbackRuns.has(prUrl)) {
-            log.info({ prUrl }, "feedback run already active for this PR — skipping");
-            return;
-        }
-        const runId = nanoid();
-        const db = this.db;
-        const runLog = createLogger({
-            component: "PipelineRunner",
-            runId,
-            issueId: issue.identifier,
-        });
-        // Copy linearTeamId from the parent run (if any) for spend-cap accounting.
-        let linearTeamId = null;
-        if (parentRunId) {
-            const parentRows = await db
-                .select({ linearTeamId: pipelineRuns.linearTeamId })
-                .from(pipelineRuns)
-                .where(eq(pipelineRuns.id, parentRunId))
-                .limit(1);
-            linearTeamId = parentRows[0]?.linearTeamId ?? null;
-        }
-        runLog.info({ branch, prUrl }, "inserting feedback run into DB");
-        await db.insert(pipelineRuns).values({
-            id: runId,
-            issueId: issue.identifier,
-            issueTitle: issue.title,
-            pipelineKey,
-            repoUrl: repoConfig.url,
-            branch,
-            status: "queued",
-            prUrl,
-            runType: "review-feedback",
-            parentRunId: parentRunId ?? null,
-            feedbackContext: JSON.stringify(feedbackComments),
-            linearTeamId,
-        });
-        const run = this.buildPipelineRun(runId, issue, pipelineKey, repoConfig, branch);
-        run.prUrl = prUrl;
-        run.runType = "review-feedback";
-        run.feedbackContext = JSON.stringify(feedbackComments);
-        // Register in activeFeedbackRuns BEFORE enqueue so rate-limit check works
-        this.activeFeedbackRuns.set(prUrl, runId);
-        this.queue
-            .enqueue(async () => {
-            if (!this.activeFeedbackRuns.has(prUrl))
-                return; // was cancelled
-            runLog.info("executing feedback pipeline");
-            try {
-                await runWithLogContext({ runId, issueId: issue.identifier }, () => this.executeFeedbackPipeline(runId, run, pipelineConfig, repoConfig, sanitizedIssue, branch, prUrl, prNumber, feedbackComments, rerequestReview ?? false));
-            }
-            catch (err) {
-                runLog.error({ err }, "feedback pipeline execution failed");
-            }
-            finally {
-                this.activeFeedbackRuns.delete(prUrl);
-            }
-        })
-            .catch((err) => {
-            runLog.error({ err }, "feedback queue execution failed");
-            this.activeFeedbackRuns.delete(prUrl);
-        });
+        const ctx = {
+            db: this.db,
+            notifier: this.notifier,
+            repoCloneDir: this.repoCloneDir,
+            agentRunDir: this.agentRunDir,
+            githubConfig: this.githubConfig,
+            gitlabConfig: this.gitlabConfig,
+            pushQueue: this.pushQueue,
+            lockAdapter: this.lockAdapter,
+            prLockTimeoutMs: this.prLockTimeoutMs,
+            budgetAlertedRuns: this.budgetAlertedRuns,
+            checkTokenBudget: this.checkTokenBudget.bind(this),
+            failPipeline: this.failPipeline.bind(this),
+            injectAgentConfig: this.injectAgentConfig.bind(this),
+            markRunCancelled: this.markRunCancelled.bind(this),
+            activeFeedbackRuns: this.activeFeedbackRuns,
+            queue: this.queue,
+            buildPipelineRun: this.buildPipelineRun.bind(this),
+        };
+        return startFeedbackPipeline(ctx, params);
     }
     /**
      * Inject the framework's CLAUDE.md into the worktree if the repo doesn't
@@ -564,6 +575,16 @@ export class PipelineRunner {
                 const stageType = stage;
                 lastStageIndex = config.stages.indexOf(stage);
                 runLog.info({ stage: stageType }, "executing stage");
+                // Operator stop check (graceful path) — fires between stages so the
+                // previous stage's work is preserved. The "cancel" path is interrupted
+                // mid-stream by the executor's AbortController and surfaces below as
+                // result.status === "cancelled".
+                const preStageStopSignal = getStopSignal(runId);
+                if (preStageStopSignal) {
+                    runLog.info({ stage: stageType, mode: preStageStopSignal }, "pipeline stop requested — aborting remaining stages");
+                    await this.markRunCancelled(db, runId, run, preStageStopSignal);
+                    return;
+                }
                 if (stageType === "await-approval") {
                     // Save the full resume context so resume() can re-attach the worktree
                     // and continue from the next stage with the correct handoff artifact.
@@ -619,6 +640,16 @@ export class PipelineRunner {
                     devcontainerSession,
                     stageModels: config.stageModels,
                 });
+                // Operator stop check (cancel path) — the AbortController inside the
+                // executor surfaces as result.status === "cancelled". Don't try to use
+                // the (possibly partial) handoff; exit immediately like the pre-stage
+                // graceful check above.
+                if (result.status === "cancelled") {
+                    const mode = getStopSignal(runId) ?? "cancel";
+                    runLog.info({ stage: stageType, mode }, "stage cancelled by operator — aborting pipeline");
+                    await this.markRunCancelled(db, runId, run, mode);
+                    return;
+                }
                 // BEC-134: track the most recent review stage_run id so fanout
                 // persistence can reuse it.
                 if (stageType === "review") {
@@ -884,18 +915,15 @@ export class PipelineRunner {
                         }
                     }
                 }
-                // After stage completes: update coordination with actual files modified
-                // so other agents can check for overlaps before starting their next stage.
+                // After stage completes: update the in-memory file list so the next
+                // stage's pre-loop upsertActiveWork persists the accumulated set.
+                // We intentionally skip a second DB write here — the row was already
+                // written at the start of this stage and will be refreshed again at
+                // the start of the next one, avoiding a redundant intermediate write.
                 if (worktreePath) {
                     const freshFiles = await getModifiedFiles(worktreePath);
                     if (freshFiles.length > 0) {
                         allModifiedFiles = freshFiles;
-                        await upsertActiveWork(db, {
-                            runId,
-                            issueId: sanitizedIssue.id,
-                            stage: stageType,
-                            filesModified: allModifiedFiles,
-                        });
                     }
                 }
             }
@@ -1684,6 +1712,8 @@ export class PipelineRunner {
                         ? 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
                             .select()
                             .from(stageRuns)
@@ -2004,249 +2034,6 @@ export class PipelineRunner {
         };
         await this.notifier.onDailyTokenSummary?.(summary);
     }
-    /**
-     * Execute a review-feedback pipeline run.
-     *
-     * Key differences from executePipeline():
-     *  - Checks out the EXISTING PR branch (not a new one).
-     *  - Skips triage, reproduce, await-approval stages.
-     *  - Does NOT create a new PR — pushes to the same branch.
-     *  - Optionally re-requests review via GitHub App after push.
-     *  - Feedback comment context is injected into the implement stage prompt.
-     */
-    async executeFeedbackPipeline(runId, run, config, repoConfig, sanitizedIssue, branch, prUrl, prNumber, feedbackComments, rerequestReview) {
-        const db = this.db;
-        const runLog = createLogger({
-            component: "PipelineRunner",
-            runId,
-            issueId: run.issueId,
-        });
-        let worktreePath;
-        let devcontainerSession;
-        await db
-            .update(pipelineRuns)
-            .set({ status: "running" })
-            .where(eq(pipelineRuns.id, runId));
-        run.status = "running";
-        await upsertActiveWork(db, {
-            runId,
-            issueId: sanitizedIssue.id,
-            stage: "implement",
-        });
-        await this.notifier.onPipelineStart(run);
-        try {
-            // -----------------------------------------------------------------------
-            // Set up worktree from existing remote branch
-            // -----------------------------------------------------------------------
-            const repoDir = `${this.repoCloneDir}/${sanitizedIssue.slug}`;
-            const cloneUrl = repoConfig.provider === "gitlab" && this.gitlabConfig
-                ? buildAuthenticatedUrl(repoConfig.url, this.gitlabConfig)
-                : repoConfig.url;
-            const logUrl = cloneUrl.replace(/:\/\/[^@]+@/, "://[redacted]@");
-            runLog.info({ repoUrl: logUrl, repoDir }, "feedback: cloning/fetching repository");
-            await cloneRepo(cloneUrl, repoDir);
-            runLog.info({ branch }, "feedback: creating worktree from existing remote branch");
-            worktreePath = await createWorktreeFromRemote(repoDir, runId, branch, this.agentRunDir);
-            runLog.info({ worktreePath }, "feedback: worktree created");
-            // Devcontainer (if configured)
-            const useDevcontainer = await shouldUseDevcontainer(worktreePath, repoConfig.devcontainer);
-            if (useDevcontainer) {
-                runLog.info("feedback: starting devcontainer");
-                devcontainerSession = await devcontainerUp(worktreePath, repoConfig.devcontainer);
-            }
-            await this.injectAgentConfig(worktreePath);
-            if (repoConfig.setupCommands) {
-                for (const cmdArgs of repoConfig.setupCommands) {
-                    const [command, ...args] = cmdArgs;
-                    runLog.info({ command, args }, "feedback: running setup command");
-                    try {
-                        await execFileAsync(command, args, { cwd: worktreePath });
-                    }
-                    catch (err) {
-                        const msg = err instanceof Error ? err.message : String(err);
-                        runLog.error({ command, args, err }, "feedback: setup command failed");
-                        throw new Error(`Setup command failed: ${command} ${args.join(" ")} — ${msg}`);
-                    }
-                }
-            }
-            const techStack = await detectTechStack(worktreePath);
-            runLog.info({
-                languages: techStack.languages,
-                frameworks: techStack.frameworks,
-                buildSystems: techStack.buildSystems,
-            }, "feedback: tech stack detected");
-            // -----------------------------------------------------------------------
-            // Build review-feedback context for the implement stage. This routes the
-            // implement template into its dedicated review-feedback branch
-            // ("address comments on existing branch, push to same branch") instead
-            // of the standard "create new branch + implement from scratch" path,
-            // which is wrong for PR-comment triggered runs.
-            // -----------------------------------------------------------------------
-            const reviewFeedback = buildReviewFeedbackContext(prUrl, branch, feedbackComments);
-            // -----------------------------------------------------------------------
-            // Execute pipeline stages — skip triage, reproduce, await-approval
-            // -----------------------------------------------------------------------
-            const skipStages = new Set(["triage", "reproduce", "await-approval"]);
-            const stagesToRun = config.stages.filter((s) => !skipStages.has(s));
-            runLog.info({ stages: stagesToRun }, "feedback: starting pipeline stages");
-            let handoff;
-            let allModifiedFiles = [];
-            for (const stage of stagesToRun) {
-                const stageType = stage;
-                runLog.info({ stage: stageType }, "feedback: executing stage");
-                await upsertActiveWork(db, {
-                    runId,
-                    issueId: sanitizedIssue.id,
-                    stage: stageType,
-                    filesModified: allModifiedFiles.length > 0 ? allModifiedFiles : undefined,
-                });
-                // Only the implement stage uses reviewFeedback; the test/review stages
-                // get their context from the implement stage's handoff.
-                const stageReviewFeedback = stageType === "implement" ? reviewFeedback : undefined;
-                let result = await executeStage({
-                    runId,
-                    issueId: sanitizedIssue.id,
-                    stage: stageType,
-                    sanitizedIssue,
-                    repoConfig,
-                    handoff,
-                    workdir: worktreePath,
-                    db: this.db,
-                    techStack,
-                    devcontainerSession,
-                    reviewFeedback: stageReviewFeedback,
-                    stageModels: config.stageModels,
-                });
-                run.totalInputTokens += result.inputTokens;
-                run.totalOutputTokens += result.outputTokens;
-                if (await this.checkTokenBudget(db, runId, run, config, stage))
-                    return;
-                await this.notifier.onStageComplete(run, stage, result);
-                if (result.status === "failed") {
-                    const errorMsg = result.errorMessage ?? "Stage failed";
-                    await this.failPipeline(db, runId, run, stage, errorMsg, false);
-                    return;
-                }
-                handoff = result.handoffArtifact;
-                if (await autoCommitChanges(worktreePath, sanitizedIssue.id, branch)) {
-                    run.autoCommitted = true;
-                }
-                if (worktreePath) {
-                    const freshFiles = await getModifiedFiles(worktreePath);
-                    if (freshFiles.length > 0) {
-                        allModifiedFiles = freshFiles;
-                        await upsertActiveWork(db, {
-                            runId,
-                            issueId: sanitizedIssue.id,
-                            stage: stageType,
-                            filesModified: allModifiedFiles,
-                        });
-                    }
-                }
-            }
-            // -----------------------------------------------------------------------
-            // Push to existing branch — no new PR
-            // -----------------------------------------------------------------------
-            await this.pushQueue.enqueue(async () => {
-                await withBranchLock(this.lockAdapter, branch, this.prLockTimeoutMs, async () => {
-                    const wtPath = worktreePath;
-                    if (await autoCommitChanges(wtPath, sanitizedIssue.id, branch)) {
-                        run.autoCommitted = true;
-                    }
-                    runLog.info({ defaultBranch: repoConfig.defaultBranch }, "feedback push: rebasing before push");
-                    const rebaseResult = await rebaseBranch(wtPath, repoConfig.defaultBranch);
-                    const feedbackHasConflicts = !rebaseResult.success && rebaseResult.hasConflicts;
-                    if (feedbackHasConflicts) {
-                        runLog.warn("feedback push: rebase conflicts — force-pushing for human review");
-                        await abortRebase(wtPath);
-                        await pushBranchForce(wtPath, branch);
-                        await this.notifier.onHumanReviewNeeded?.(run, prUrl, "Merge conflicts in feedback run — please resolve manually");
-                    }
-                    else {
-                        const feedbackPushStrategy = choosePushStrategy(branch, false);
-                        if (feedbackPushStrategy === "force-with-lease") {
-                            runLog.info({ branch }, "feedback push: force-with-lease push for agent branch");
-                            await pushBranchForce(wtPath, branch);
-                        }
-                        else {
-                            await pushBranch(wtPath, branch);
-                        }
-                    }
-                    runLog.info({ prUrl }, "feedback: pushed to existing PR branch");
-                    // Re-request review via GitHub App if configured
-                    if (rerequestReview && this.githubConfig && prNumber) {
-                        try {
-                            const { owner, repo } = parseRepoUrl(repoConfig.url);
-                            const octokit = await createGitHubClient(this.githubConfig);
-                            const reRequested = await rerequestPRReview(octokit, owner, repo, prNumber);
-                            if (reRequested) {
-                                runLog.info({ prUrl, prNumber }, "feedback: re-requested review");
-                            }
-                            else {
-                                runLog.info({ prUrl, prNumber }, "feedback: no existing reviewers to re-request");
-                            }
-                        }
-                        catch (reviewErr) {
-                            runLog.error({ err: reviewErr }, "feedback: failed to re-request review");
-                        }
-                    }
-                });
-            });
-            await db
-                .update(pipelineRuns)
-                .set({
-                status: "completed",
-                completedAt: new Date(),
-                totalInputTokens: run.totalInputTokens,
-                totalOutputTokens: run.totalOutputTokens,
-                prUrl,
-                autoCommitted: run.autoCommitted ?? null,
-            })
-                .where(eq(pipelineRuns.id, runId));
-            run.status = "completed";
-            runLog.info({
-                prUrl,
-                totalInputTokens: run.totalInputTokens,
-                totalOutputTokens: run.totalOutputTokens,
-                autoCommitted: run.autoCommitted ?? false,
-            }, "feedback pipeline completed");
-            await this.notifier.onPipelineComplete(run, {
-                prUrl,
-                totalInputTokens: run.totalInputTokens,
-                totalOutputTokens: run.totalOutputTokens,
-                stagesCompleted: stagesToRun.length,
-                autoMerged: false,
-            });
-        }
-        catch (error) {
-            const errorMsg = error instanceof Error ? error.message : String(error);
-            runLog.error({ err: error }, "feedback pipeline failed with unexpected error");
-            await this.failPipeline(db, runId, run, "unknown", errorMsg, true);
-        }
-        finally {
-            this.budgetAlertedRuns.delete(runId);
-            await removeActiveWork(db, runId);
-            if (devcontainerSession) {
-                try {
-                    await devcontainerDown(devcontainerSession);
-                }
-                catch {
-                    // Ignore cleanup errors
-                }
-            }
-            // Feedback runs don't pause — always clean up worktree on completion or failure.
-            // Cast to string because failPipeline mutates run.status at runtime beyond the initial type.
-            const feedbackStatus = run.status;
-            if (worktreePath && (feedbackStatus === "completed" || feedbackStatus === "failed")) {
-                try {
-                    await deleteWorktree(worktreePath);
-                }
-                catch {
-                    // Ignore cleanup errors
-                }
-            }
-        }
-    }
     buildPipelineRun(runId, issue, pipelineKey, repoConfig, branch) {
         return {
             id: runId,