patchrelay 0.36.7 → 0.36.9

package/dist/run-completion-policy.js

@@ -0,0 +1,412 @@
+import { ACTIVE_RUN_STATES } from "./factory-state.js";
+import { execCommand } from "./utils.js";
+import { resolveImplementationDeliveryMode, } from "./prompting/patchrelay.js";
+function isRequestedChangesRunType(runType) {
+    return runType === "review_fix" || runType === "branch_upkeep";
+}
+function resolvePostRunState(issue) {
+    if (ACTIVE_RUN_STATES.has(issue.factoryState) && issue.prNumber) {
+        if (issue.prState === "merged")
+            return "done";
+        if (issue.prReviewState === "approved")
+            return "awaiting_queue";
+        return "pr_open";
+    }
+    return undefined;
+}
+export function resolveCompletedRunState(issue, run) {
+    if (run.runType === "implementation" && resolveImplementationDeliveryMode(issue, undefined, run.promptText) === "linear_only") {
+        return "done";
+    }
+    return resolvePostRunState(issue);
+}
+function normalizeRemotePrState(value) {
+    const normalized = value?.trim().toUpperCase();
+    if (normalized === "OPEN")
+        return "open";
+    if (normalized === "CLOSED")
+        return "closed";
+    if (normalized === "MERGED")
+        return "merged";
+    return undefined;
+}
+function normalizeRemoteReviewDecision(value) {
+    const normalized = value?.trim().toUpperCase();
+    if (normalized === "APPROVED")
+        return "approved";
+    if (normalized === "CHANGES_REQUESTED")
+        return "changes_requested";
+    if (normalized === "REVIEW_REQUIRED")
+        return "commented";
+    return undefined;
+}
+function isDirtyMergeStateStatus(value) {
+    return value?.trim().toUpperCase() === "DIRTY";
+}
+function buildReviewFixBranchUpkeepContext(prNumber, baseBranch, pr, context) {
+    const promptContext = [
+        `The requested code change may already be present, but GitHub still reports PR #${prNumber} as ${String(pr.mergeStateStatus)} against latest ${baseBranch}.`,
+        `This turn is branch upkeep on the existing PR branch: update onto latest ${baseBranch}, resolve any conflicts, rerun the narrowest relevant verification, and push a newer head.`,
+        "Do not stop just because the requested code change is already present. Review can only move forward after a new pushed head.",
+    ].join(" ");
+    return {
+        ...(context ?? {}),
+        branchUpkeepRequired: true,
+        reviewFixMode: "branch_upkeep",
+        wakeReason: "branch_upkeep",
+        promptContext,
+        ...(pr.mergeStateStatus ? { mergeStateStatus: pr.mergeStateStatus } : {}),
+        ...(pr.headRefOid ? { failingHeadSha: pr.headRefOid } : {}),
+        baseBranch,
+    };
+}
+export class RunCompletionPolicy {
+    config;
+    db;
+    logger;
+    withHeldLease;
+    constructor(config, db, logger, withHeldLease) {
+        this.config = config;
+        this.db = db;
+        this.logger = logger;
+        this.withHeldLease = withHeldLease;
+    }
+    async verifyReactiveRunAdvancedBranch(run, issue) {
+        if (run.runType !== "ci_repair" && run.runType !== "queue_repair") {
+            return undefined;
+        }
+        if (!issue.prNumber || issue.prState !== "open" || !issue.lastGitHubFailureHeadSha) {
+            return undefined;
+        }
+        const project = this.config.projects.find((entry) => entry.id === run.projectId);
+        if (!project?.github?.repoFullName) {
+            return undefined;
+        }
+        try {
+            const pr = await this.loadRemotePrState(project.github.repoFullName, issue.prNumber);
+            if (!pr || pr.state?.toUpperCase() !== "OPEN")
+                return undefined;
+            if (!pr.headRefOid || pr.headRefOid !== issue.lastGitHubFailureHeadSha)
+                return undefined;
+            return `Repair finished but PR #${issue.prNumber} is still on failing head ${issue.lastGitHubFailureHeadSha.slice(0, 8)}`;
+        }
+        catch (error) {
+            this.logger.debug({
+                issueKey: issue.issueKey,
+                prNumber: issue.prNumber,
+                error: error instanceof Error ? error.message : String(error),
+            }, "Failed to verify PR head advancement after repair");
+            return undefined;
+        }
+    }
+    async verifyReviewFixAdvancedHead(run, issue) {
+        if (!isRequestedChangesRunType(run.runType)) {
+            return undefined;
+        }
+        if (!issue.prNumber || issue.prState !== "open") {
+            return undefined;
+        }
+        if (!run.sourceHeadSha) {
+            return `Requested-changes run finished for PR #${issue.prNumber} without a recorded starting head SHA. PatchRelay cannot verify that a new head was published.`;
+        }
+        const project = this.config.projects.find((entry) => entry.id === run.projectId);
+        if (!project?.github?.repoFullName) {
+            return undefined;
+        }
+        try {
+            const pr = await this.loadRemotePrState(project.github.repoFullName, issue.prNumber);
+            if (!pr || pr.state?.toUpperCase() !== "OPEN")
+                return undefined;
+            if (!pr.headRefOid) {
+                return `Requested-changes run finished for PR #${issue.prNumber} but GitHub did not report a current head SHA.`;
+            }
+            if (pr.headRefOid === run.sourceHeadSha) {
+                return `Requested-changes run finished for PR #${issue.prNumber} without pushing a new head; PatchRelay must not hand the same SHA back to review.`;
+            }
+            return undefined;
+        }
+        catch (error) {
+            this.logger.debug({
+                issueKey: issue.issueKey,
+                prNumber: issue.prNumber,
+                error: error instanceof Error ? error.message : String(error),
+            }, "Failed to verify PR head advancement after requested-changes work");
+            return undefined;
+        }
+    }
+    async refreshIssueAfterReactivePublish(run, issue) {
+        if (run.runType !== "ci_repair" && run.runType !== "queue_repair" && !isRequestedChangesRunType(run.runType)) {
+            return this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? issue;
+        }
+        if (!issue.prNumber) {
+            return this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? issue;
+        }
+        const project = this.config.projects.find((entry) => entry.id === run.projectId);
+        const repoFullName = project?.github?.repoFullName;
+        if (!repoFullName) {
+            return this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? issue;
+        }
+        try {
+            const pr = await this.loadRemotePrState(repoFullName, issue.prNumber);
+            if (!pr) {
+                return this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? issue;
+            }
+            const nextPrState = normalizeRemotePrState(pr.state);
+            const nextReviewState = normalizeRemoteReviewDecision(pr.reviewDecision);
+            const gateCheckName = project?.gateChecks?.find((entry) => entry.trim())?.trim() ?? "verify";
+            const headAdvanced = Boolean(pr.headRefOid && pr.headRefOid !== issue.lastGitHubFailureHeadSha);
+            const reviewFixHeadAdvanced = isRequestedChangesRunType(run.runType)
+                && Boolean(pr.headRefOid && run.sourceHeadSha && pr.headRefOid !== run.sourceHeadSha);
+            this.upsertIssueIfLeaseHeld(run.projectId, run.linearIssueId, {
+                projectId: run.projectId,
+                linearIssueId: run.linearIssueId,
+                ...(nextPrState ? { prState: nextPrState } : {}),
+                ...(pr.headRefOid ? { prHeadSha: pr.headRefOid } : {}),
+                ...(nextReviewState ? { prReviewState: nextReviewState } : {}),
+                ...((headAdvanced || reviewFixHeadAdvanced)
+                    ? {
+                        prCheckStatus: "pending",
+                        lastGitHubFailureSource: null,
+                        lastGitHubFailureHeadSha: null,
+                        lastGitHubFailureSignature: null,
+                        lastGitHubFailureCheckName: null,
+                        lastGitHubFailureCheckUrl: null,
+                        lastGitHubFailureContextJson: null,
+                        lastGitHubFailureAt: null,
+                        lastQueueIncidentJson: null,
+                        lastAttemptedFailureHeadSha: null,
+                        lastAttemptedFailureSignature: null,
+                        lastGitHubCiSnapshotHeadSha: pr.headRefOid ?? null,
+                        lastGitHubCiSnapshotGateCheckName: gateCheckName,
+                        lastGitHubCiSnapshotGateCheckStatus: "pending",
+                        lastGitHubCiSnapshotJson: null,
+                        lastGitHubCiSnapshotSettledAt: null,
+                    }
+                    : {}),
+            }, "reactive publish refresh");
+        }
+        catch (error) {
+            this.logger.debug({
+                issueKey: issue.issueKey,
+                prNumber: issue.prNumber,
+                error: error instanceof Error ? error.message : String(error),
+            }, "Failed to refresh PR state after reactive publish");
+        }
+        return this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? issue;
+    }
+    async resolveRequestedChangesWakeContext(issue, runType, context) {
+        if (runType === "branch_upkeep" || context?.branchUpkeepRequired === true) {
+            return context;
+        }
+        if (!issue.prNumber || issue.prState !== "open" || issue.prReviewState !== "changes_requested") {
+            return context;
+        }
+        const project = this.config.projects.find((entry) => entry.id === issue.projectId);
+        const repoFullName = project?.github?.repoFullName;
+        if (!repoFullName) {
+            return context;
+        }
+        try {
+            const pr = await this.loadRemotePrState(repoFullName, issue.prNumber);
+            if (!pr)
+                return context;
+            const nextPrState = normalizeRemotePrState(pr.state);
+            const nextReviewState = normalizeRemoteReviewDecision(pr.reviewDecision);
+            this.upsertIssueIfLeaseHeld(issue.projectId, issue.linearIssueId, {
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                ...(nextPrState ? { prState: nextPrState } : {}),
+                ...(pr.headRefOid ? { prHeadSha: pr.headRefOid } : {}),
+                ...(nextReviewState ? { prReviewState: nextReviewState } : {}),
+            }, "review-fix wake refresh");
+            if (nextPrState !== "open")
+                return context;
+            if (nextReviewState && nextReviewState !== "changes_requested")
+                return context;
+            if (!isDirtyMergeStateStatus(pr.mergeStateStatus))
+                return context;
+            return buildReviewFixBranchUpkeepContext(issue.prNumber, project?.github?.baseBranch ?? "main", pr, context);
+        }
+        catch (error) {
+            this.logger.debug({
+                issueKey: issue.issueKey,
+                prNumber: issue.prNumber,
+                error: error instanceof Error ? error.message : String(error),
+            }, "Failed to resolve requested-changes wake context");
+            return context;
+        }
+    }
+    async resolvePostRunFollowUp(run, issue) {
+        if (run.runType !== "review_fix") {
+            return undefined;
+        }
+        if (!issue.prNumber || issue.prState !== "open") {
+            return undefined;
+        }
+        if (issue.prReviewState !== "changes_requested") {
+            return undefined;
+        }
+        const project = this.config.projects.find((entry) => entry.id === run.projectId);
+        const repoFullName = project?.github?.repoFullName;
+        if (!repoFullName) {
+            return undefined;
+        }
+        try {
+            const pr = await this.loadRemotePrState(repoFullName, issue.prNumber);
+            if (!pr)
+                return undefined;
+            const nextPrState = normalizeRemotePrState(pr.state);
+            const nextReviewState = normalizeRemoteReviewDecision(pr.reviewDecision);
+            this.upsertIssueIfLeaseHeld(issue.projectId, issue.linearIssueId, {
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                ...(nextPrState ? { prState: nextPrState } : {}),
+                ...(pr.headRefOid ? { prHeadSha: pr.headRefOid } : {}),
+                ...(nextReviewState ? { prReviewState: nextReviewState } : {}),
+            }, "post-run follow-up refresh");
+            if (nextPrState !== "open")
+                return undefined;
+            if (nextReviewState && nextReviewState !== "changes_requested")
+                return undefined;
+            if (!isDirtyMergeStateStatus(pr.mergeStateStatus))
+                return undefined;
+            return {
+                pendingRunType: "branch_upkeep",
+                factoryState: "changes_requested",
+                context: buildReviewFixBranchUpkeepContext(issue.prNumber, project?.github?.baseBranch ?? "main", pr),
+                summary: `PR #${issue.prNumber} is still dirty after review fix; queued branch upkeep`,
+            };
+        }
+        catch (error) {
+            this.logger.debug({
+                issueKey: issue.issueKey,
+                prNumber: issue.prNumber,
+                error: error instanceof Error ? error.message : String(error),
+            }, "Failed to resolve post-run PR upkeep");
+            return undefined;
+        }
+    }
+    async verifyPublishedRunOutcome(run, issue) {
+        if (run.runType !== "implementation") {
+            return undefined;
+        }
+        const project = this.config.projects.find((entry) => entry.id === run.projectId);
+        const baseBranch = project?.github?.baseBranch ?? "main";
+        const deliveryMode = resolveImplementationDeliveryMode(issue, undefined, run.promptText);
+        if (deliveryMode === "linear_only") {
+            if (issue.prNumber !== undefined) {
+                return `Planning-only implementation should not open a PR, but PR #${issue.prNumber} was observed`;
+            }
+            return this.describeLocalImplementationOutcome(issue, baseBranch, deliveryMode);
+        }
+        if (issue.prNumber && issue.prState && issue.prState !== "closed") {
+            return undefined;
+        }
+        if (project?.github?.repoFullName && issue.branchName) {
+            try {
+                const { stdout, exitCode } = await execCommand("gh", [
+                    "pr",
+                    "list",
+                    "--repo",
+                    project.github.repoFullName,
+                    "--head",
+                    issue.branchName,
+                    "--state",
+                    "all",
+                    "--json",
+                    "number,url,state,author,headRefOid",
+                ], { timeoutMs: 10_000 });
+                if (exitCode === 0) {
+                    const matches = JSON.parse(stdout);
+                    const pr = matches[0];
+                    if (pr?.number) {
+                        this.upsertIssueIfLeaseHeld(issue.projectId, issue.linearIssueId, {
+                            projectId: issue.projectId,
+                            linearIssueId: issue.linearIssueId,
+                            prNumber: pr.number,
+                            ...(pr.url ? { prUrl: pr.url } : {}),
+                            ...(pr.state ? { prState: pr.state.toLowerCase() } : {}),
+                            ...(pr.headRefOid ? { prHeadSha: pr.headRefOid } : {}),
+                            ...(pr.author?.login ? { prAuthorLogin: pr.author.login } : {}),
+                        }, "published PR verification refresh");
+                        return undefined;
+                    }
+                }
+            }
+            catch (error) {
+                this.logger.debug({
+                    issueKey: issue.issueKey,
+                    branchName: issue.branchName,
+                    repoFullName: project.github.repoFullName,
+                    error: error instanceof Error ? error.message : String(error),
+                }, "Failed to verify published PR state after implementation");
+            }
+        }
+        const details = await this.describeLocalImplementationOutcome(issue, baseBranch, deliveryMode);
+        return details ?? `Implementation completed without opening a PR for branch ${issue.branchName ?? issue.linearIssueId}`;
+    }
+    async loadRemotePrState(repoFullName, prNumber) {
+        const { stdout, exitCode } = await execCommand("gh", [
+            "pr", "view", String(prNumber),
+            "--repo", repoFullName,
+            "--json", "headRefOid,state,reviewDecision,mergeStateStatus",
+        ], { timeoutMs: 10_000 });
+        if (exitCode !== 0)
+            return undefined;
+        return JSON.parse(stdout);
+    }
+    upsertIssueIfLeaseHeld(projectId, linearIssueId, params, context) {
+        const updated = this.withHeldLease(projectId, linearIssueId, (lease) => this.db.issueSessions.upsertIssueWithLease(lease, params));
+        if (updated === undefined) {
+            this.logger.warn({ projectId, linearIssueId, context }, "Skipping issue write after losing issue-session lease");
+        }
+        return updated;
+    }
+    async describeLocalImplementationOutcome(issue, baseBranch, deliveryMode = "publish_pr") {
+        if (!issue.worktreePath) {
+            return undefined;
+        }
+        try {
+            const status = await execCommand(this.config.runner.gitBin, [
+                "-C",
+                issue.worktreePath,
+                "status",
+                "--short",
+            ], { timeoutMs: 10_000 });
+            const dirtyEntries = status.exitCode === 0
+                ? status.stdout.split("\n").map((line) => line.trim()).filter(Boolean)
+                : [];
+            if (dirtyEntries.length > 0) {
+                if (deliveryMode === "linear_only") {
+                    return `Planning-only implementation should not modify the repo; worktree still has ${dirtyEntries.length} uncommitted change(s)`;
+                }
+                return `Implementation completed without opening a PR; worktree still has ${dirtyEntries.length} uncommitted change(s)`;
+            }
+        }
+        catch {
+            // Best effort only.
+        }
+        try {
+            const ahead = await execCommand(this.config.runner.gitBin, [
+                "-C",
+                issue.worktreePath,
+                "rev-list",
+                "--count",
+                `origin/${baseBranch}..HEAD`,
+            ], { timeoutMs: 10_000 });
+            if (ahead.exitCode === 0) {
+                const count = Number(ahead.stdout.trim());
+                if (Number.isFinite(count) && count > 0) {
+                    if (deliveryMode === "linear_only") {
+                        return `Planning-only implementation should not create repo commits; worktree is ${count} local commit(s) ahead of origin/${baseBranch}`;
+                    }
+                    return `Implementation completed with ${count} local commit(s) ahead of origin/${baseBranch} but no PR was observed`;
+                }
+            }
+        }
+        catch {
+            // Best effort only.
+        }
+        return undefined;
+    }
+}

package/dist/run-finalizer.js

@@ -0,0 +1,172 @@
+import { buildStageReport, countEventMethods } from "./run-reporting.js";
+import { buildRunCompletedActivity, buildRunFailureActivity } from "./linear-session-reporting.js";
+import { resolveCompletedRunState } from "./run-completion-policy.js";
+export class RunFinalizer {
+    db;
+    logger;
+    linearSync;
+    enqueueIssue;
+    withHeldLease;
+    releaseLease;
+    appendWakeEventWithLease;
+    failRunAndClear;
+    completionPolicy;
+    feed;
+    constructor(db, logger, linearSync, enqueueIssue, withHeldLease, releaseLease, appendWakeEventWithLease, failRunAndClear, completionPolicy, feed) {
+        this.db = db;
+        this.logger = logger;
+        this.linearSync = linearSync;
+        this.enqueueIssue = enqueueIssue;
+        this.withHeldLease = withHeldLease;
+        this.releaseLease = releaseLease;
+        this.appendWakeEventWithLease = appendWakeEventWithLease;
+        this.failRunAndClear = failRunAndClear;
+        this.completionPolicy = completionPolicy;
+        this.feed = feed;
+    }
+    async finalizeCompletedRun(params) {
+        const { run, issue, thread, threadId } = params;
+        const trackedIssue = this.db.issueToTrackedIssue(issue);
+        const report = buildStageReport({ ...run, status: "completed" }, trackedIssue, thread, countEventMethods(this.db.runs.listThreadEvents(run.id)));
+        const freshIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? issue;
+        const verifiedRepairError = await this.completionPolicy.verifyReactiveRunAdvancedBranch(run, freshIssue);
+        if (verifiedRepairError) {
+            const holdState = params.resolveRecoverableRunState(freshIssue) ?? "failed";
+            this.failRunAndClear(run, verifiedRepairError, holdState);
+            const heldIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? freshIssue;
+            this.feed?.publish({
+                level: "warn",
+                kind: "turn",
+                issueKey: freshIssue.issueKey,
+                projectId: run.projectId,
+                stage: run.runType,
+                status: "branch_not_advanced",
+                summary: verifiedRepairError,
+            });
+            void this.linearSync.emitActivity(heldIssue, buildRunFailureActivity(run.runType, verifiedRepairError));
+            void this.linearSync.syncSession(heldIssue, { activeRunType: run.runType });
+            this.linearSync.clearProgress(run.id);
+            this.releaseLease(run.projectId, run.linearIssueId);
+            return;
+        }
+        const missingReviewFixHeadError = await this.completionPolicy.verifyReviewFixAdvancedHead(run, freshIssue);
+        if (missingReviewFixHeadError) {
+            this.failRunAndClear(run, missingReviewFixHeadError, "escalated");
+            const failedIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? freshIssue;
+            this.feed?.publish({
+                level: "error",
+                kind: "turn",
+                issueKey: freshIssue.issueKey,
+                projectId: run.projectId,
+                stage: run.runType,
+                status: "same_head_review_handoff_blocked",
+                summary: missingReviewFixHeadError,
+            });
+            void this.linearSync.emitActivity(failedIssue, buildRunFailureActivity(run.runType, missingReviewFixHeadError));
+            void this.linearSync.syncSession(failedIssue, { activeRunType: run.runType });
+            this.linearSync.clearProgress(run.id);
+            this.releaseLease(run.projectId, run.linearIssueId);
+            return;
+        }
+        const publishedOutcomeError = await this.completionPolicy.verifyPublishedRunOutcome(run, freshIssue);
+        if (publishedOutcomeError) {
+            this.failRunAndClear(run, publishedOutcomeError, "failed");
+            const failedIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? freshIssue;
+            this.feed?.publish({
+                level: "warn",
+                kind: "turn",
+                issueKey: freshIssue.issueKey,
+                projectId: run.projectId,
+                stage: run.runType,
+                status: "publish_incomplete",
+                summary: publishedOutcomeError,
+            });
+            void this.linearSync.emitActivity(failedIssue, buildRunFailureActivity(run.runType, publishedOutcomeError));
+            void this.linearSync.syncSession(failedIssue, { activeRunType: run.runType });
+            this.linearSync.clearProgress(run.id);
+            if (params.source === "notification") {
+                this.releaseLease(run.projectId, run.linearIssueId);
+            }
+            return;
+        }
+        const refreshedIssue = await this.completionPolicy.refreshIssueAfterReactivePublish(run, freshIssue);
+        const postRunFollowUp = await this.completionPolicy.resolvePostRunFollowUp(run, refreshedIssue);
+        const postRunState = postRunFollowUp?.factoryState ?? resolveCompletedRunState(refreshedIssue, run);
+        const completed = this.withHeldLease(run.projectId, run.linearIssueId, (lease) => {
+            this.db.runs.finishRun(run.id, {
+                status: "completed",
+                threadId,
+                ...(params.completedTurnId ? { turnId: params.completedTurnId } : {}),
+                summaryJson: JSON.stringify({ latestAssistantMessage: report.assistantMessages.at(-1) ?? null }),
+                reportJson: JSON.stringify(report),
+            });
+            this.db.issues.upsertIssue({
+                projectId: run.projectId,
+                linearIssueId: run.linearIssueId,
+                activeRunId: null,
+                ...(postRunState ? { factoryState: postRunState } : {}),
+                pendingRunType: null,
+                pendingRunContextJson: null,
+                ...(postRunFollowUp ? {} : (postRunState === "awaiting_queue" || postRunState === "done"
+                    ? {
+                        lastGitHubFailureSource: null,
+                        lastGitHubFailureHeadSha: null,
+                        lastGitHubFailureSignature: null,
+                        lastGitHubFailureCheckName: null,
+                        lastGitHubFailureCheckUrl: null,
+                        lastGitHubFailureContextJson: null,
+                        lastGitHubFailureAt: null,
+                        lastQueueIncidentJson: null,
+                        lastAttemptedFailureHeadSha: null,
+                        lastAttemptedFailureSignature: null,
+                    }
+                    : {})),
+            });
+            if (postRunFollowUp) {
+                return this.appendWakeEventWithLease(lease, issue, postRunFollowUp.pendingRunType, postRunFollowUp.context, "post_run");
+            }
+            return true;
+        });
+        if (!completed) {
+            this.logger.warn({ runId: run.id, issueId: run.linearIssueId }, "Skipping completion writes after losing issue-session lease");
+            this.linearSync.clearProgress(run.id);
+            this.releaseLease(run.projectId, run.linearIssueId);
+            return;
+        }
+        if (postRunFollowUp) {
+            this.feed?.publish({
+                level: "info",
+                kind: "stage",
+                issueKey: issue.issueKey,
+                projectId: run.projectId,
+                stage: postRunFollowUp.factoryState,
+                status: "follow_up_queued",
+                summary: postRunFollowUp.summary,
+            });
+            this.enqueueIssue(run.projectId, run.linearIssueId);
+        }
+        this.feed?.publish({
+            level: "info",
+            kind: "turn",
+            issueKey: issue.issueKey,
+            projectId: run.projectId,
+            stage: run.runType,
+            status: "completed",
+            summary: params.source === "notification"
+                ? `Turn completed for ${run.runType}`
+                : `Reconciliation: ${run.runType} completed${postRunState ? ` -> ${postRunState}` : ""}`,
+            ...(report.assistantMessages.at(-1) ? { detail: report.assistantMessages.at(-1) } : {}),
+        });
+        const updatedIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? refreshedIssue;
+        const completionSummary = report.assistantMessages.at(-1)?.slice(0, 300) ?? `${run.runType} completed.`;
+        void this.linearSync.emitActivity(updatedIssue, buildRunCompletedActivity({
+            runType: run.runType,
+            completionSummary,
+            postRunState: updatedIssue.factoryState,
+            ...(updatedIssue.prNumber !== undefined ? { prNumber: updatedIssue.prNumber } : {}),
+        }));
+        void this.linearSync.syncSession(updatedIssue);
+        this.linearSync.clearProgress(run.id);
+        this.releaseLease(run.projectId, run.linearIssueId);
+    }
+}