patchrelay 0.38.2 → 0.39.0

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.38.2",
-  "commit": "9cecc8b13d85",
-  "builtAt": "2026-04-11T08:10:12.086Z"
+  "version": "0.39.0",
+  "commit": "80d285a7e9bd",
+  "builtAt": "2026-04-11T20:04:29.313Z"
 }

package/dist/github-worktree-auth.js

@@ -0,0 +1,18 @@
+import { execCommand } from "./utils.js";
+function shellSingleQuote(value) {
+    return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+export function buildGitHubBotCredentialHelper(tokenFile) {
+    const quotedTokenFile = shellSingleQuote(tokenFile);
+    return `!f() { [ "$1" = get ] || exit 0; echo "username=x-access-token"; echo "password=$(cat ${quotedTokenFile})"; }; f`;
+}
+export async function configureGitHubBotAuthForWorktree(params) {
+    const helper = buildGitHubBotCredentialHelper(params.botIdentity.tokenFile);
+    const gitArgs = ["-C", params.worktreePath, "config"];
+    await execCommand(params.gitBin, [...gitArgs, "user.name", params.botIdentity.name], { timeoutMs: 5_000 });
+    await execCommand(params.gitBin, [...gitArgs, "user.email", params.botIdentity.email], { timeoutMs: 5_000 });
+    // Clear inherited GitHub-specific helpers such as `gh auth git-credential`
+    // so git HTTPS operations use the same bot token as the wrapped `gh` CLI.
+    await execCommand(params.gitBin, [...gitArgs, "--replace-all", "credential.https://github.com.helper", ""], { timeoutMs: 5_000 });
+    await execCommand(params.gitBin, [...gitArgs, "--add", "credential.https://github.com.helper", helper], { timeoutMs: 5_000 });
+}

package/dist/linear-progress-facts.js

@@ -0,0 +1,170 @@
+import { sanitizeOperatorFacingText } from "./presentation-text.js";
+export function deriveLinearProgressFact(notification, issue) {
+    switch (notification.method) {
+        case "item/completed":
+            return deriveProgressFactFromCompletedItem(notification.params.item, issue);
+        case "turn/plan/updated":
+            return deriveProgressFactFromPlan(notification.params.plan, issue);
+        default:
+            return undefined;
+    }
+}
+function deriveProgressFactFromCompletedItem(rawItem, issue) {
+    void issue;
+    if (!rawItem || typeof rawItem !== "object") {
+        return undefined;
+    }
+    const item = rawItem;
+    if (item.type !== "agentMessage" || typeof item.text !== "string") {
+        return undefined;
+    }
+    const body = compactOperatorSentence(item.text);
+    if (!body) {
+        return undefined;
+    }
+    if (looksLikeVerification(body)) {
+        return {
+            kind: "verification_started",
+            meaningKey: `verification:${normalizeMeaningKey(body)}`,
+            content: { type: "thought", body },
+        };
+    }
+    if (looksLikePublishing(body)) {
+        return {
+            kind: "publishing_started",
+            meaningKey: `publishing:${normalizeMeaningKey(body)}`,
+            content: { type: "thought", body },
+        };
+    }
+    if (looksLikeRootCause(body)) {
+        return {
+            kind: "root_cause_found",
+            meaningKey: `finding:${normalizeMeaningKey(body)}`,
+            content: { type: "thought", body },
+        };
+    }
+    return undefined;
+}
+function deriveProgressFactFromPlan(rawPlan, issue) {
+    if (!Array.isArray(rawPlan)) {
+        return undefined;
+    }
+    const activeStep = rawPlan
+        .map((entry) => normalizePlanEntry(entry))
+        .find((entry) => entry && entry.status === "in_progress");
+    if (!activeStep) {
+        return undefined;
+    }
+    if (looksLikeVerification(activeStep.step)) {
+        return {
+            kind: "verification_started",
+            meaningKey: `verification:${normalizeMeaningKey(activeStep.step)}`,
+            content: {
+                type: "action",
+                action: "Verifying",
+                parameter: summarizePlanStep(activeStep.step, "latest changes before publishing"),
+            },
+        };
+    }
+    if (looksLikePublishing(activeStep.step)) {
+        const parameter = summarizePlanStep(activeStep.step, issue?.prNumber !== undefined ? `changes to PR #${issue.prNumber}` : "latest changes");
+        return {
+            kind: "publishing_started",
+            meaningKey: `publishing:${normalizeMeaningKey(activeStep.step)}`,
+            content: {
+                type: "action",
+                action: "Publishing",
+                parameter,
+            },
+        };
+    }
+    return undefined;
+}
+function normalizePlanEntry(rawEntry) {
+    if (!rawEntry || typeof rawEntry !== "object") {
+        return undefined;
+    }
+    const entry = rawEntry;
+    const rawStep = entry.step;
+    if (typeof rawStep !== "string" || !rawStep.trim()) {
+        return undefined;
+    }
+    const rawStatus = typeof entry.status === "string" ? entry.status : "pending";
+    return {
+        step: rawStep.trim(),
+        status: rawStatus === "inProgress" ? "in_progress"
+            : rawStatus === "completed" ? "completed"
+                : rawStatus === "pending" ? "pending"
+                    : rawStatus === "in_progress" ? "in_progress"
+                        : "pending",
+    };
+}
+function looksLikeRootCause(text) {
+    const normalized = text.toLowerCase();
+    return /\b(narrowed|isolated|root cause)\b/.test(normalized)
+        || normalized.startsWith("found that ")
+        || normalized.startsWith("the failure is isolated")
+        || normalized.startsWith("the issue is isolated");
+}
+function looksLikeVerification(text) {
+    const normalized = text.toLowerCase();
+    return /\b(verifying|verification|targeted verification|smoke)\b/.test(normalized);
+}
+function looksLikePublishing(text) {
+    const normalized = text.toLowerCase();
+    return /\b(publish|publishing|push|pushing)\b/.test(normalized)
+        || normalized.includes("opening pr")
+        || normalized.includes("opening the pr")
+        || normalized.includes("opening pull request");
+}
+function compactOperatorSentence(text, maxLength = 160) {
+    const sanitized = sanitizeOperatorFacingText(text)?.replace(/\s+/g, " ").trim();
+    if (!sanitized) {
+        return undefined;
+    }
+    if (sanitized.length <= maxLength) {
+        return sanitized;
+    }
+    const punctuated = lastBoundaryWithinLimit(sanitized, maxLength, /[.;!?]/g);
+    if (punctuated !== undefined) {
+        return sanitized.slice(0, punctuated + 1).trim();
+    }
+    const spaced = sanitized.lastIndexOf(" ", maxLength);
+    if (spaced > 0) {
+        return `${sanitized.slice(0, spaced).trimEnd()}...`;
+    }
+    return `${sanitized.slice(0, maxLength).trimEnd()}...`;
+}
+function summarizePlanStep(step, fallback) {
+    const sanitized = sanitizeOperatorFacingText(step)?.replace(/\s+/g, " ").trim();
+    if (!sanitized) {
+        return fallback;
+    }
+    const stripped = sanitized
+        .replace(/^(run|running|start|starting)\s+/i, "")
+        .replace(/^(verify|verifying|verification of)\s+/i, "")
+        .replace(/^(publish|publishing|push|pushing|open|opening)\s+/i, "")
+        .trim()
+        .replace(/[.]+$/, "");
+    return stripped || fallback;
+}
+function normalizeMeaningKey(text) {
+    return text
+        .toLowerCase()
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function lastBoundaryWithinLimit(text, maxLength, pattern) {
+    let last = -1;
+    for (;;) {
+        const match = pattern.exec(text);
+        if (!match) {
+            break;
+        }
+        if (match.index >= maxLength) {
+            break;
+        }
+        last = match.index;
+    }
+    return last >= 0 ? last : undefined;
+}

package/dist/linear-progress-reporter.js

@@ -1,11 +1,38 @@
+import { deriveLinearProgressFact } from "./linear-progress-facts.js";
 export class LinearProgressReporter {
-    constructor(_db, _emitActivity) { }
-    maybeEmitProgress(_notification, _run) {
-        // Keep routine Codex progress in local/operator surfaces rather than
-        // turning every planning or reasoning update into Linear thread chatter.
-        return;
+    db;
+    emitActivity;
+    publicationsByRun = new Map();
+    constructor(db, emitActivity) {
+        this.db = db;
+        this.emitActivity = emitActivity;
     }
-    clearProgress(_runId) {
-        return;
+    maybeEmitProgress(notification, run) {
+        const issue = this.db.getIssue(run.projectId, run.linearIssueId);
+        if (!issue) {
+            return;
+        }
+        const fact = deriveLinearProgressFact(notification, issue);
+        if (!fact) {
+            return;
+        }
+        const previous = this.publicationsByRun.get(run.id);
+        if (previous?.meaningKey === fact.meaningKey) {
+            return;
+        }
+        const publication = {
+            meaningKey: fact.meaningKey,
+            publishedAtMs: Date.now(),
+        };
+        this.publicationsByRun.set(run.id, publication);
+        void this.emitActivity(issue, fact.content, { ephemeral: true }).catch(() => {
+            const current = this.publicationsByRun.get(run.id);
+            if (current?.publishedAtMs === publication.publishedAtMs && current.meaningKey === publication.meaningKey) {
+                this.publicationsByRun.delete(run.id);
+            }
+        });
+    }
+    clearProgress(runId) {
+        this.publicationsByRun.delete(runId);
     }
 }

package/dist/linear-workflow-state-sync.js

@@ -1,22 +1,24 @@
-import { resolvePreferredDeployingLinearState, resolvePreferredHumanNeededLinearState, resolvePreferredImplementingLinearState, resolvePreferredReviewLinearState, resolvePreferredReviewingLinearState, } from "./linear-workflow.js";
+import { resolvePreferredCompletedLinearState, resolvePreferredDeployingLinearState, resolvePreferredHumanNeededLinearState, resolvePreferredImplementingLinearState, resolvePreferredReviewLinearState, resolvePreferredReviewingLinearState, } from "./linear-workflow.js";
+import { isCompletedLinearState } from "./pr-state.js";
+import { hasTrustedNoPrCompletion } from "./trusted-no-pr-completion.js";
 export async function syncActiveWorkflowState(params) {
     const { db, issue, linear, trackedIssue, options } = params;
-    if (!shouldAutoAdvanceLinearState(issue)) {
-        return;
-    }
     const liveIssue = await linear.getIssue(issue.linearIssueId).catch(() => undefined);
     if (!liveIssue)
         return;
+    const latestRun = db.runs.getLatestRunForIssue(issue.projectId, issue.linearIssueId);
+    if (hasTrustedNoPrCompletion(issue, latestRun)) {
+        await syncCompletedLinearState({ db, issue, linear, liveIssue });
+        return;
+    }
+    if (!shouldAutoAdvanceLinearState(issue)) {
+        return;
+    }
     if (!shouldAutoAdvanceLinearState({
         currentLinearState: liveIssue.stateName,
         currentLinearStateType: liveIssue.stateType,
     })) {
-        db.issues.upsertIssue({
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
-            ...(liveIssue.stateName ? { currentLinearState: liveIssue.stateName } : {}),
-            ...(liveIssue.stateType ? { currentLinearStateType: liveIssue.stateType } : {}),
-        });
+        refreshCachedLinearState(db, issue, liveIssue.stateName, liveIssue.stateType);
         return;
     }
     const targetState = resolveDesiredActiveWorkflowState(issue, trackedIssue, options, liveIssue);
@@ -24,20 +26,37 @@ export async function syncActiveWorkflowState(params) {
         return;
     const normalizedCurrent = liveIssue.stateName?.trim().toLowerCase();
     if (normalizedCurrent === targetState.trim().toLowerCase()) {
-        db.issues.upsertIssue({
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
-            ...(liveIssue.stateName ? { currentLinearState: liveIssue.stateName } : {}),
-            ...(liveIssue.stateType ? { currentLinearStateType: liveIssue.stateType } : {}),
-        });
+        refreshCachedLinearState(db, issue, liveIssue.stateName, liveIssue.stateType);
         return;
     }
     const updated = await linear.setIssueState(issue.linearIssueId, targetState);
+    refreshCachedLinearState(db, issue, updated.stateName, updated.stateType);
+}
+async function syncCompletedLinearState(params) {
+    const { db, issue, linear, liveIssue } = params;
+    if (isCompletedLinearState(liveIssue.stateType, liveIssue.stateName)) {
+        refreshCachedLinearState(db, issue, liveIssue.stateName, liveIssue.stateType);
+        return;
+    }
+    const targetState = resolvePreferredCompletedLinearState(liveIssue);
+    if (!targetState) {
+        refreshCachedLinearState(db, issue, liveIssue.stateName, liveIssue.stateType);
+        return;
+    }
+    const normalizedCurrent = liveIssue.stateName?.trim().toLowerCase();
+    if (normalizedCurrent === targetState.trim().toLowerCase()) {
+        refreshCachedLinearState(db, issue, liveIssue.stateName, liveIssue.stateType);
+        return;
+    }
+    const updated = await linear.setIssueState(issue.linearIssueId, targetState);
+    refreshCachedLinearState(db, issue, updated.stateName, updated.stateType);
+}
+function refreshCachedLinearState(db, issue, stateName, stateType) {
     db.issues.upsertIssue({
         projectId: issue.projectId,
         linearIssueId: issue.linearIssueId,
-        ...(updated.stateName ? { currentLinearState: updated.stateName } : {}),
-        ...(updated.stateType ? { currentLinearStateType: updated.stateType } : {}),
+        ...(stateName ? { currentLinearState: stateName } : {}),
+        ...(stateType ? { currentLinearStateType: stateType } : {}),
     });
 }
 function shouldAutoAdvanceLinearState(issue) {

package/dist/merged-linear-completion-reconciler.js

@@ -1,4 +1,7 @@
+import { deriveIssueSessionReactiveIntent } from "./issue-session.js";
 import { resolvePreferredCompletedLinearState } from "./linear-workflow.js";
+import { isCompletedLinearState } from "./pr-state.js";
+import { hasTrustedNoPrCompletion } from "./trusted-no-pr-completion.js";
 export class MergedLinearCompletionReconciler {
     db;
     linearProvider;
@@ -10,39 +13,116 @@ export class MergedLinearCompletionReconciler {
     }
     async reconcile() {
         for (const issue of this.db.issues.listIssues()) {
-            if (issue.prState !== "merged")
-                continue;
-            if (issue.currentLinearStateType?.trim().toLowerCase() === "completed")
+            if (issue.factoryState !== "done" && issue.prState !== "merged") {
                 continue;
+            }
             const linear = await this.linearProvider.forProject(issue.projectId).catch(() => undefined);
-            if (!linear)
+            if (!linear) {
                 continue;
+            }
             try {
                 const liveIssue = await linear.getIssue(issue.linearIssueId);
-                const targetState = resolvePreferredCompletedLinearState(liveIssue);
-                if (!targetState)
-                    continue;
-                const normalizedCurrent = liveIssue.stateName?.trim().toLowerCase();
-                if (normalizedCurrent === targetState.trim().toLowerCase()) {
-                    this.db.issues.upsertIssue({
-                        projectId: issue.projectId,
-                        linearIssueId: issue.linearIssueId,
-                        ...(liveIssue.stateName ? { currentLinearState: liveIssue.stateName } : {}),
-                        ...(liveIssue.stateType ? { currentLinearStateType: liveIssue.stateType } : {}),
-                    });
-                    continue;
-                }
-                const updated = await linear.setIssueState(issue.linearIssueId, targetState);
-                this.db.issues.upsertIssue({
+                this.db.issues.replaceIssueDependencies({
                     projectId: issue.projectId,
                     linearIssueId: issue.linearIssueId,
-                    ...(updated.stateName ? { currentLinearState: updated.stateName } : {}),
-                    ...(updated.stateType ? { currentLinearStateType: updated.stateType } : {}),
+                    blockers: liveIssue.blockedBy.map((blocker) => ({
+                        blockerLinearIssueId: blocker.id,
+                        ...(blocker.identifier ? { blockerIssueKey: blocker.identifier } : {}),
+                        ...(blocker.title ? { blockerTitle: blocker.title } : {}),
+                        ...(blocker.stateName ? { blockerCurrentLinearState: blocker.stateName } : {}),
+                        ...(blocker.stateType ? { blockerCurrentLinearStateType: blocker.stateType } : {}),
+                    })),
                 });
+                const latestRun = this.db.runs.getLatestRunForIssue(issue.projectId, issue.linearIssueId);
+                const trustedNoPrDone = hasTrustedNoPrCompletion(issue, latestRun);
+                if (issue.prState === "merged" || trustedNoPrDone) {
+                    await this.reconcileCompletedLinearState(issue, liveIssue, linear);
+                    continue;
+                }
+                if (issue.factoryState === "done" && !isCompletedLinearState(liveIssue.stateType, liveIssue.stateName)) {
+                    this.reopenStaleLocalDoneIssue(issue, liveIssue);
+                }
+                else {
+                    this.refreshCachedLinearState(issue, liveIssue);
+                }
             }
             catch (error) {
-                this.logger.warn({ issueKey: issue.issueKey, error: error instanceof Error ? error.message : String(error) }, "Failed to reconcile merged issue to a completed Linear state");
+                this.logger.warn({ issueKey: issue.issueKey, error: error instanceof Error ? error.message : String(error) }, "Failed to reconcile merged or stale completed issue state");
             }
         }
     }
+    async reconcileCompletedLinearState(issue, liveIssue, linear) {
+        if (isCompletedLinearState(liveIssue.stateType, liveIssue.stateName)) {
+            this.refreshCachedLinearState(issue, liveIssue);
+            return;
+        }
+        const targetState = resolvePreferredCompletedLinearState(liveIssue);
+        if (!targetState) {
+            this.refreshCachedLinearState(issue, liveIssue);
+            return;
+        }
+        const normalizedCurrent = liveIssue.stateName?.trim().toLowerCase();
+        if (normalizedCurrent === targetState.trim().toLowerCase()) {
+            this.refreshCachedLinearState(issue, liveIssue);
+            return;
+        }
+        const updated = await linear.setIssueState(issue.linearIssueId, targetState);
+        this.db.issues.upsertIssue({
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            ...(updated.stateName ? { currentLinearState: updated.stateName } : {}),
+            ...(updated.stateType ? { currentLinearStateType: updated.stateType } : {}),
+        });
+    }
+    reopenStaleLocalDoneIssue(issue, liveIssue) {
+        const restored = resolveOpenWorkflowState(issue);
+        this.db.issues.upsertIssue({
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            ...(liveIssue.stateName ? { currentLinearState: liveIssue.stateName } : {}),
+            ...(liveIssue.stateType ? { currentLinearStateType: liveIssue.stateType } : {}),
+            ...(restored ? { factoryState: restored.factoryState } : {}),
+            ...(restored ? { pendingRunType: restored.pendingRunType } : {}),
+        });
+        this.logger.info({
+            issueKey: issue.issueKey,
+            previousFactoryState: issue.factoryState,
+            restoredFactoryState: restored?.factoryState,
+            liveLinearState: liveIssue.stateName,
+        }, "Reopened stale local done state from live Linear workflow");
+    }
+    refreshCachedLinearState(issue, liveIssue) {
+        this.db.issues.upsertIssue({
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            ...(liveIssue.stateName ? { currentLinearState: liveIssue.stateName } : {}),
+            ...(liveIssue.stateType ? { currentLinearStateType: liveIssue.stateType } : {}),
+        });
+    }
+}
+function resolveOpenWorkflowState(issue) {
+    const reactiveIntent = deriveIssueSessionReactiveIntent({
+        delegatedToPatchRelay: issue.delegatedToPatchRelay,
+        prNumber: issue.prNumber,
+        prState: issue.prState,
+        prReviewState: issue.prReviewState,
+        prCheckStatus: issue.prCheckStatus,
+        latestFailureSource: issue.lastGitHubFailureSource,
+    });
+    if (reactiveIntent) {
+        return {
+            factoryState: reactiveIntent.compatibilityFactoryState,
+            pendingRunType: reactiveIntent.runType,
+        };
+    }
+    if (issue.prNumber !== undefined && (issue.prState === undefined || issue.prState === "open")) {
+        if (issue.prReviewState === "approved" && (issue.prCheckStatus === "success" || issue.prCheckStatus === "passed")) {
+            return { factoryState: "awaiting_queue", pendingRunType: null };
+        }
+        return { factoryState: "pr_open", pendingRunType: null };
+    }
+    if (issue.delegatedToPatchRelay) {
+        return { factoryState: "delegated", pendingRunType: null };
+    }
+    return undefined;
 }

package/dist/no-pr-completion-check.js

@@ -1,4 +1,11 @@
 import { buildCompletionCheckActivity } from "./linear-session-reporting.js";
+function shouldContinueForUnpublishedLocalChanges(message) {
+    const normalized = message.trim().toLowerCase();
+    if (!normalized)
+        return false;
+    return normalized.includes("worktree still has")
+        || (normalized.includes("local commit") && normalized.includes("ahead of origin/"));
+}
 export async function handleNoPrCompletionCheck(params) {
     const completedRunUpdate = buildCompletedRunUpdate({
         threadId: params.threadId,
@@ -115,6 +122,51 @@ export async function handleNoPrCompletionCheck(params) {
         return;
     }
     if (completionCheck.outcome === "done") {
+        if (shouldContinueForUnpublishedLocalChanges(params.publishedOutcomeError)) {
+            const continued = params.withHeldLease(params.run.projectId, params.run.linearIssueId, (lease) => {
+                params.db.runs.finishRun(params.run.id, completedRunUpdate);
+                params.db.runs.saveCompletionCheck(params.run.id, {
+                    ...completionCheck,
+                    outcome: "continue",
+                    summary: "PatchRelay changed files locally but has not published them yet; continuing automatically to finish publication.",
+                    why: params.publishedOutcomeError,
+                });
+                params.db.issues.upsertIssue({
+                    projectId: params.run.projectId,
+                    linearIssueId: params.run.linearIssueId,
+                    activeRunId: null,
+                    factoryState: "delegated",
+                    pendingRunType: null,
+                    pendingRunContextJson: null,
+                });
+                return Boolean(params.db.issueSessions.appendIssueSessionEventWithLease(lease, {
+                    projectId: params.run.projectId,
+                    linearIssueId: params.run.linearIssueId,
+                    eventType: "completion_check_continue",
+                    eventJson: JSON.stringify({
+                        runType: params.run.runType,
+                        summary: params.publishedOutcomeError,
+                    }),
+                    dedupeKey: `completion_check_continue:${params.run.id}`,
+                }));
+            });
+            if (!continued) {
+                params.logger.warn({ runId: params.run.id, issueId: params.run.linearIssueId }, "Skipping completion-check continue writes after losing issue-session lease");
+                params.clearProgressAndRelease(params.run);
+                return;
+            }
+            params.syncCompletionCheckOutcome({
+                run: params.run,
+                fallbackIssue: params.issue,
+                level: "info",
+                status: "completion_check_continue",
+                summary: "No PR found; continuing automatically to finish publication",
+                detail: params.publishedOutcomeError,
+                activity: buildCompletionCheckActivity("continue"),
+                enqueue: true,
+            });
+            return;
+        }
         const completed = params.withHeldLease(params.run.projectId, params.run.linearIssueId, (lease) => {
             params.db.runs.finishRun(params.run.id, completedRunUpdate);
             params.db.runs.saveCompletionCheck(params.run.id, completionCheck);

package/dist/run-launcher.js

@@ -2,7 +2,7 @@ import { buildHookEnv, runProjectHook } from "./hook-runner.js";
 import { buildRunFailureActivity } from "./linear-session-reporting.js";
 import { loadPatchRelayRepoPrompting } from "./patchrelay-customization.js";
 import { buildRunPrompt as buildPatchRelayRunPrompt, findDisallowedPatchRelayPromptSectionIds, findUnknownPatchRelayPromptSectionIds, mergePromptCustomizationLayers, resolvePromptLayers, } from "./prompting/patchrelay.js";
-import { execCommand } from "./utils.js";
+import { configureGitHubBotAuthForWorktree } from "./github-worktree-auth.js";
 function slugify(value) {
     return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60);
 }
@@ -116,11 +116,11 @@ export class RunLauncher {
         try {
             await this.worktreeManager.ensureIssueWorktree(params.project.repoPath, params.project.worktreeRoot, params.worktreePath, params.branchName, { allowExistingOutsideRoot: params.issue.branchName !== undefined });
             if (params.botIdentity) {
-                const gitBin = this.config.runner.gitBin;
-                await execCommand(gitBin, ["-C", params.worktreePath, "config", "user.name", params.botIdentity.name], { timeoutMs: 5_000 });
-                await execCommand(gitBin, ["-C", params.worktreePath, "config", "user.email", params.botIdentity.email], { timeoutMs: 5_000 });
-                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 configureGitHubBotAuthForWorktree({
+                    gitBin: this.config.runner.gitBin,
+                    worktreePath: params.worktreePath,
+                    botIdentity: params.botIdentity,
+                });
             }
             await this.worktreeManager.resetWorktreeToTrackedBranch(params.worktreePath, params.branchName, params.issue, this.logger);
             if (params.runType !== "queue_repair") {

package/dist/trusted-no-pr-completion.js

@@ -0,0 +1,7 @@
+export function hasTrustedNoPrCompletion(issue, latestRun) {
+    return issue.factoryState === "done"
+        && issue.prNumber === undefined
+        && !issue.prUrl
+        && latestRun?.status === "completed"
+        && latestRun.completionCheckOutcome === "done";
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "patchrelay",
-  "version": "0.38.2",
+  "version": "0.39.0",
   "license": "MIT",
   "type": "module",
   "repository": {