patchrelay 0.36.8 → 0.36.10

package/dist/linear-session-sync.js

@@ -26,7 +26,7 @@ export class LinearSessionSync {
         if (!recoveredAgentSessionId)
             return issue;
         this.logger.info({ issueKey: issue.issueKey, agentSessionId: recoveredAgentSessionId }, "Recovered missing Linear agent session id from webhook history");
-        return this.db.upsertIssue({
+        return this.db.issues.upsertIssue({
             projectId: issue.projectId,
             linearIssueId: issue.linearIssueId,
             agentSessionId: recoveredAgentSessionId,
@@ -99,7 +99,7 @@ export class LinearSessionSync {
             currentLinearState: liveIssue.stateName,
             currentLinearStateType: liveIssue.stateType,
         })) {
-            this.db.upsertIssue({
+            this.db.issues.upsertIssue({
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,
                 ...(liveIssue.stateName ? { currentLinearState: liveIssue.stateName } : {}),
@@ -112,7 +112,7 @@ export class LinearSessionSync {
             return;
         const normalizedCurrent = liveIssue.stateName?.trim().toLowerCase();
         if (normalizedCurrent === targetState.trim().toLowerCase()) {
-            this.db.upsertIssue({
+            this.db.issues.upsertIssue({
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,
                 ...(liveIssue.stateName ? { currentLinearState: liveIssue.stateName } : {}),
@@ -121,7 +121,7 @@ export class LinearSessionSync {
             return;
         }
         const updated = await linear.setIssueState(issue.linearIssueId, targetState);
-        this.db.upsertIssue({
+        this.db.issues.upsertIssue({
             projectId: issue.projectId,
             linearIssueId: issue.linearIssueId,
             ...(updated.stateName ? { currentLinearState: updated.stateName } : {}),
@@ -174,7 +174,7 @@ export class LinearSessionSync {
         if (now - lastEmit < PROGRESS_THROTTLE_MS)
             return;
         this.progressThrottle.set(run.id, now);
-        const issue = this.db.getIssue(run.projectId, run.linearIssueId);
+        const issue = this.db.issues.getIssue(run.projectId, run.linearIssueId);
         if (issue) {
             void this.emitActivity(issue, activity, { ephemeral: true });
         }
@@ -192,7 +192,7 @@ export class LinearSessionSync {
                 body,
             });
             if (result.id !== issue.statusCommentId) {
-                this.db.upsertIssue({
+                this.db.issues.upsertIssue({
                     projectId: issue.projectId,
                     linearIssueId: issue.linearIssueId,
                     statusCommentId: result.id,

package/dist/queue-health-monitor.js

@@ -25,7 +25,7 @@ export class QueueHealthMonitor {
         this.feed = feed;
     }
     async reconcile() {
-        for (const issue of this.db.listAwaitingQueueIssues()) {
+        for (const issue of this.db.issues.listAwaitingQueueIssues()) {
             await this.probeQueuedIssue(issue);
         }
     }
@@ -68,7 +68,7 @@ export class QueueHealthMonitor {
         }
         this.probeFailureFeedTimes.delete(`${issue.projectId}::${issue.linearIssueId}`);
         if (pr.state === "MERGED") {
-            this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, prState: "merged" });
+            this.db.issues.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, prState: "merged" });
             this.advancer.advanceIdleIssue(issue, "done", { clearFailureProvenance: true });
             return;
         }
@@ -101,7 +101,7 @@ export class QueueHealthMonitor {
             if (isDuplicateProbe(issue, pendingRunContext)) {
                 return;
             }
-            this.db.upsertIssue({
+            this.db.issues.upsertIssue({
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,
                 lastAttemptedFailureHeadSha: headRefOid,

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

@@ -1,28 +1,39 @@
 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, 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.getIssue(run.projectId, run.linearIssueId) ?? issue;
-        const verifiedRepairError = await params.verifyReactiveRunAdvancedBranch(run, freshIssue);
+        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";
-            params.failRunAndClear(run, verifiedRepairError, holdState);
-            const heldIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? freshIssue;
+            this.failRunAndClear(run, verifiedRepairError, holdState);
+            const heldIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? freshIssue;
             this.feed?.publish({
                 level: "warn",
                 kind: "turn",
@@ -35,13 +46,13 @@ export class RunFinalizer {
             void this.linearSync.emitActivity(heldIssue, buildRunFailureActivity(run.runType, verifiedRepairError));
             void this.linearSync.syncSession(heldIssue, { activeRunType: run.runType });
             this.linearSync.clearProgress(run.id);
-            params.releaseLease(run.projectId, run.linearIssueId);
+            this.releaseLease(run.projectId, run.linearIssueId);
             return;
         }
-        const missingReviewFixHeadError = await params.verifyReviewFixAdvancedHead(run, freshIssue);
+        const missingReviewFixHeadError = await this.completionPolicy.verifyReviewFixAdvancedHead(run, freshIssue);
         if (missingReviewFixHeadError) {
-            params.failRunAndClear(run, missingReviewFixHeadError, "escalated");
-            const failedIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? freshIssue;
+            this.failRunAndClear(run, missingReviewFixHeadError, "escalated");
+            const failedIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? freshIssue;
             this.feed?.publish({
                 level: "error",
                 kind: "turn",
@@ -54,13 +65,13 @@ export class RunFinalizer {
             void this.linearSync.emitActivity(failedIssue, buildRunFailureActivity(run.runType, missingReviewFixHeadError));
             void this.linearSync.syncSession(failedIssue, { activeRunType: run.runType });
             this.linearSync.clearProgress(run.id);
-            params.releaseLease(run.projectId, run.linearIssueId);
+            this.releaseLease(run.projectId, run.linearIssueId);
             return;
         }
-        const publishedOutcomeError = await params.verifyPublishedRunOutcome(run, freshIssue);
+        const publishedOutcomeError = await this.completionPolicy.verifyPublishedRunOutcome(run, freshIssue);
         if (publishedOutcomeError) {
-            params.failRunAndClear(run, publishedOutcomeError, "failed");
-            const failedIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? freshIssue;
+            this.failRunAndClear(run, publishedOutcomeError, "failed");
+            const failedIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? freshIssue;
             this.feed?.publish({
                 level: "warn",
                 kind: "turn",
@@ -74,14 +85,14 @@ export class RunFinalizer {
             void this.linearSync.syncSession(failedIssue, { activeRunType: run.runType });
             this.linearSync.clearProgress(run.id);
             if (params.source === "notification") {
-                params.releaseLease(run.projectId, run.linearIssueId);
+                this.releaseLease(run.projectId, run.linearIssueId);
             }
             return;
         }
-        const refreshedIssue = await params.refreshIssueAfterReactivePublish(run, freshIssue);
-        const postRunFollowUp = await params.resolvePostRunFollowUp(run, refreshedIssue);
-        const postRunState = postRunFollowUp?.factoryState ?? params.resolveCompletedRunState(refreshedIssue, run);
-        const completed = params.withHeldLease(run.projectId, run.linearIssueId, (lease) => {
+        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,
@@ -89,7 +100,7 @@ export class RunFinalizer {
                 summaryJson: JSON.stringify({ latestAssistantMessage: report.assistantMessages.at(-1) ?? null }),
                 reportJson: JSON.stringify(report),
             });
-            this.db.upsertIssue({
+            this.db.issues.upsertIssue({
                 projectId: run.projectId,
                 linearIssueId: run.linearIssueId,
                 activeRunId: null,
@@ -112,14 +123,14 @@ export class RunFinalizer {
                     : {})),
             });
             if (postRunFollowUp) {
-                return params.appendWakeEventWithLease(lease, issue, postRunFollowUp.pendingRunType, postRunFollowUp.context, "post_run");
+                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);
-            params.releaseLease(run.projectId, run.linearIssueId);
+            this.releaseLease(run.projectId, run.linearIssueId);
             return;
         }
         if (postRunFollowUp) {
@@ -146,7 +157,7 @@ export class RunFinalizer {
                 : `Reconciliation: ${run.runType} completed${postRunState ? ` -> ${postRunState}` : ""}`,
             ...(report.assistantMessages.at(-1) ? { detail: report.assistantMessages.at(-1) } : {}),
         });
-        const updatedIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? refreshedIssue;
+        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,
@@ -156,6 +167,6 @@ export class RunFinalizer {
         }));
         void this.linearSync.syncSession(updatedIssue);
         this.linearSync.clearProgress(run.id);
-        params.releaseLease(run.projectId, run.linearIssueId);
+        this.releaseLease(run.projectId, run.linearIssueId);
     }
 }

package/dist/run-launcher.js

@@ -61,7 +61,7 @@ export class RunLauncher {
     }
     claimRun(params) {
         return this.db.issueSessions.withIssueSessionLease(params.item.projectId, params.item.issueId, params.leaseId, () => {
-            const fresh = this.db.getIssue(params.item.projectId, params.item.issueId);
+            const fresh = this.db.issues.getIssue(params.item.projectId, params.item.issueId);
             if (!fresh || fresh.activeRunId !== undefined)
                 return undefined;
             const wakeIssue = params.materializeLegacyPendingWake(fresh, {
@@ -84,7 +84,7 @@ export class RunLauncher {
                 ? params.effectiveContext.failureHeadSha
                 : typeof params.effectiveContext?.headSha === "string" ? params.effectiveContext.headSha : undefined;
             const failureSignature = typeof params.effectiveContext?.failureSignature === "string" ? params.effectiveContext.failureSignature : undefined;
-            this.db.upsertIssue({
+            this.db.issues.upsertIssue({
                 projectId: params.item.projectId,
                 linearIssueId: params.item.issueId,
                 pendingRunType: null,
@@ -123,9 +123,9 @@ export class RunLauncher {
                 const credentialHelper = `!f() { echo "username=x-access-token"; echo "password=$(cat ${params.botIdentity.tokenFile})"; }; f`;
                 await execCommand(gitBin, ["-C", params.worktreePath, "config", "credential.helper", credentialHelper], { timeoutMs: 5_000 });
             }
-            await params.resetWorktreeToTrackedBranch(params.worktreePath, params.branchName, params.issue);
+            await this.worktreeManager.resetWorktreeToTrackedBranch(params.worktreePath, params.branchName, params.issue, this.logger);
             if (params.runType !== "queue_repair") {
-                await params.freshenWorktree(params.worktreePath, params.project, params.issue);
+                await this.worktreeManager.freshenWorktree(params.worktreePath, params.project, params.issue, this.logger);
             }
             const hookEnv = buildHookEnv(params.issue.issueKey ?? params.issue.linearIssueId, params.branchName, params.runType, params.worktreePath);
             const prepareResult = await runProjectHook(params.project.repoPath, "prepare-worktree", { cwd: params.worktreePath, env: hookEnv });
@@ -183,7 +183,7 @@ export class RunLauncher {
                 });
             }
             this.logger.error({ issueKey: params.issue.issueKey, runType: params.runType, error: message }, `Failed to launch ${params.runType} run`);
-            const failedIssue = this.db.getIssue(params.project.id, params.issue.linearIssueId) ?? params.issue;
+            const failedIssue = this.db.issues.getIssue(params.project.id, params.issue.linearIssueId) ?? params.issue;
             void params.linearSync.emitActivity(failedIssue, buildRunFailureActivity(params.runType, `Failed to start ${params.lowerCaseFirst(message)}`));
             void params.linearSync.syncSession(failedIssue, { activeRunType: params.runType });
             params.releaseLease(params.project.id, params.issue.linearIssueId);