patchrelay 0.38.2 → 0.40.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.40.0",
+  "commit": "c1cef920f5e3",
+  "builtAt": "2026-04-11T22:19:02.944Z"
 }

package/dist/cli/commands/issues.js

@@ -2,7 +2,7 @@ import { setTimeout as delay } from "node:timers/promises";
 import { getRunTypeFlag } from "../args.js";
 import { CliUsageError } from "../errors.js";
 import { formatJson } from "../formatters/json.js";
-import { formatClose, formatInspect, formatList, formatLive, formatOpen, formatRetry, formatSessionHistory, formatWorktree } from "../formatters/text.js";
+import { formatClose, formatInspect, formatList, formatLive, formatOpen, formatRetry, formatSessionHistory, formatTranscriptSource, formatWorktree } from "../formatters/text.js";
 import { buildOpenCommand } from "../interactive.js";
 import { writeOutput } from "../output.js";
 export async function handleIssueCommand(params) {
@@ -36,6 +36,8 @@ export async function handleIssueCommand(params) {
             return await handleOpenCommand(nested);
         case "sessions":
             return await handleSessionsCommand(nested);
+        case "transcript-source":
+            return await handleTranscriptSourceCommand(nested);
         case "retry":
             return await handleRetryCommand(nested);
         case "close":
@@ -116,6 +118,30 @@ export async function handleOpenCommand(params) {
     const openCommand = buildOpenCommand(params.config, result.worktreePath, result.resumeThreadId);
     return await params.runInteractive(openCommand.command, openCommand.args);
 }
+export async function handleTranscriptSourceCommand(params) {
+    const issueKey = params.commandArgs[0];
+    if (!issueKey) {
+        throw new Error("transcript-source requires <issueKey>.");
+    }
+    const runFlag = params.parsed.flags.get("run");
+    let runId;
+    if (typeof runFlag === "string") {
+        const parsedRunId = Number(runFlag);
+        if (!Number.isSafeInteger(parsedRunId) || parsedRunId <= 0) {
+            throw new Error("--run must be a positive integer.");
+        }
+        runId = parsedRunId;
+    }
+    const result = params.data.transcriptSource(issueKey, runId);
+    if (!result) {
+        throw new Error(`Issue not found: ${issueKey}`);
+    }
+    if (runId !== undefined && result.runId !== runId) {
+        throw new Error(`Run not found for ${issueKey}: ${runId}`);
+    }
+    writeOutput(params.stdout, params.json ? formatJson(result) : formatTranscriptSource(result));
+    return 0;
+}
 export async function handleSessionsCommand(params) {
     const issueKey = params.commandArgs[0];
     if (!issueKey) {

package/dist/cli/data.js

@@ -1,6 +1,7 @@
 import { existsSync } from "node:fs";
 import pino from "pino";
 import { CodexAppServerClient } from "../codex-app-server.js";
+import { resolveCodexSessionSource } from "../codex-session-source.js";
 import { extractCompletionCheck } from "../completion-check.js";
 import { getThreadTurns } from "../codex-thread-utils.js";
 import { PatchRelayDatabase } from "../db.js";
@@ -272,6 +273,25 @@ export class CliDataAccess extends CliOperatorApiClient {
             ...(run ? { releasedRunId: run.id } : {}),
         };
     }
+    transcriptSource(issueKey, runId) {
+        const issue = this.db.getTrackedIssueByKey(issueKey);
+        if (!issue)
+            return undefined;
+        const dbIssue = this.db.issues.getIssueByKey(issueKey);
+        const runs = this.db.runs.listRunsForIssue(issue.projectId, issue.linearIssueId);
+        const selectedRun = runId !== undefined
+            ? runs.find((run) => run.id === runId)
+            : runs.slice().reverse().find((run) => run.threadId);
+        const threadId = selectedRun?.threadId ?? dbIssue.threadId;
+        return {
+            issue,
+            ...(selectedRun ? { runId: selectedRun.id, runType: selectedRun.runType, runStatus: selectedRun.status } : {}),
+            ...(threadId ? { threadId } : {}),
+            ...(selectedRun?.turnId ? { turnId: selectedRun.turnId } : {}),
+            ...(dbIssue.worktreePath ? { worktreePath: dbIssue.worktreePath } : {}),
+            ...(threadId ? { sessionSource: resolveCodexSessionSource(threadId) } : {}),
+        };
+    }
     sessions(issueKey) {
         const issue = this.db.getTrackedIssueByKey(issueKey);
         if (!issue)
@@ -284,6 +304,7 @@ export class CliDataAccess extends CliOperatorApiClient {
             .map((run) => {
             const summary = summarizeRun(run);
             const eventCount = this.db.runs.listThreadEvents(run.id).length;
+            const sessionSource = run.threadId ? resolveCodexSessionSource(run.threadId) : undefined;
             return {
                 runId: run.id,
                 runType: run.runType,
@@ -293,6 +314,7 @@ export class CliDataAccess extends CliOperatorApiClient {
                 ...(run.parentThreadId ? { parentThreadId: run.parentThreadId } : {}),
                 ...(summary ? { summary } : {}),
                 ...(run.failureReason ? { failureReason: run.failureReason } : {}),
+                ...(sessionSource ? { sessionSource } : {}),
                 eventCount,
                 eventCountAvailable: this.config.runner.codex.persistExtendedHistory || eventCount > 0,
                 startedAt: run.startedAt,

package/dist/cli/formatters/text.js

@@ -97,6 +97,29 @@ export function formatClose(result) {
 function formatTimestampRange(startedAt, endedAt) {
     return endedAt ? `${startedAt} -> ${endedAt}` : `${startedAt} -> running`;
 }
+function formatSessionSource(sessionSource) {
+    if (!sessionSource)
+        return undefined;
+    if (sessionSource.exists)
+        return sessionSource.path;
+    return sessionSource.error ?? "not found";
+}
+export function formatTranscriptSource(result) {
+    const lines = [
+        value("Issue", result.issue.issueKey ?? result.issue.linearIssueId),
+        value("Worktree", result.worktreePath),
+        value("Run", result.runId !== undefined
+            ? `#${result.runId}${result.runType ? ` ${result.runType}` : ""}${result.runStatus ? ` (${result.runStatus})` : ""}`
+            : undefined),
+        value("Thread", result.threadId),
+        value("Turn", result.turnId),
+        value("Session source", formatSessionSource(result.sessionSource)),
+        result.sessionSource?.startedAt ? value("Started", result.sessionSource.startedAt) : undefined,
+        result.sessionSource?.originator ? value("Originator", result.sessionSource.originator) : undefined,
+        result.sessionSource?.cwd ? value("Working directory", result.sessionSource.cwd) : undefined,
+    ].filter(Boolean);
+    return `${lines.join("\n")}\n`;
+}
 export function formatSessionHistory(result, buildOpenForThread) {
     const lines = [
         `${result.issue.issueKey ?? result.issue.linearIssueId}${result.issue.currentLinearState ? `  ${result.issue.currentLinearState}` : ""}`,
@@ -134,6 +157,18 @@ export function formatSessionHistory(result, buildOpenForThread) {
         else if (session.failureReason) {
             lines.push(value("Failure", truncateLine(session.failureReason)));
         }
+        if (session.sessionSource) {
+            lines.push(value("Session source", formatSessionSource(session.sessionSource)));
+            if (session.sessionSource.startedAt) {
+                lines.push(value("Started", session.sessionSource.startedAt));
+            }
+            if (session.sessionSource.originator) {
+                lines.push(value("Originator", session.sessionSource.originator));
+            }
+            if (session.sessionSource.cwd) {
+                lines.push(value("Working directory", session.sessionSource.cwd));
+            }
+        }
         if (session.threadId && result.worktreePath && buildOpenForThread) {
             const command = buildOpenForThread(session.threadId);
             lines.push(value("Open", formatCommand(command.command, command.args)));

package/dist/cli/help.js

@@ -37,6 +37,7 @@ export function rootHelpText() {
         "  issue watch <issueKey> [--json]                         Follow the active run until it settles",
         "  issue open <issueKey> [--print] [--json]                Open Codex in the issue worktree",
         "  issue sessions <issueKey> [--json]                      Show recorded Codex app-server sessions for one issue",
+        "  issue transcript-source <issueKey> [--run <id>] [--json]  Show the raw Codex session file for one issue run",
         "  issue close <issueKey> [--failed] [--reason <text>] [--json]",
         "                                                          Force-close one issue and release any active run",
         "  service status [--json]                                 Show systemd state and local health",
@@ -150,6 +151,7 @@ export function issueHelpText() {
         "  path <issueKey>                 Print the issue worktree path",
         "  open <issueKey>                 Open Codex in the issue worktree",
         "  sessions <issueKey>             Show recorded Codex app-server sessions",
+        "  transcript-source <issueKey>    Show the raw Codex session file for one issue run",
         "  retry <issueKey>                Requeue a run",
         "  close <issueKey>                Force-close a stuck issue",
         "",
@@ -158,6 +160,7 @@ export function issueHelpText() {
         "  patchrelay issue show USE-54",
         "  patchrelay issue watch USE-54",
         "  patchrelay issue sessions USE-54",
+        "  patchrelay issue transcript-source USE-54",
         "  patchrelay close USE-54 --reason \"already handled manually\"",
     ].join("\n");
 }

package/dist/cli/index.js

@@ -64,6 +64,9 @@ function validateFlags(command, commandArgs, parsed) {
                 case "sessions":
                     assertKnownFlags(parsed, "issue", ["json"]);
                     return;
+                case "transcript-source":
+                    assertKnownFlags(parsed, "issue", ["run", "json"]);
+                    return;
                 case "retry":
                     assertKnownFlags(parsed, "issue", ["run-type", "reason", "json"]);
                     return;

package/dist/codex-session-source.js

@@ -0,0 +1,85 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+function resolveCodexHome(explicit) {
+    return explicit
+        ?? process.env.CODEX_HOME
+        ?? path.join(homedir(), ".codex");
+}
+function walkSessionFiles(directory, threadId, matches) {
+    const entries = readdirSync(directory, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(directory, entry.name);
+        if (entry.isDirectory()) {
+            walkSessionFiles(fullPath, threadId, matches);
+            continue;
+        }
+        if (!entry.isFile() || !entry.name.endsWith(".jsonl")) {
+            continue;
+        }
+        if (entry.name.includes(threadId)) {
+            matches.push(fullPath);
+        }
+    }
+}
+function readSessionMeta(filePath) {
+    try {
+        const firstLine = readFileSync(filePath, "utf8").split(/\r?\n/, 1)[0];
+        if (!firstLine) {
+            return { error: "session file is empty" };
+        }
+        const parsed = JSON.parse(firstLine);
+        if (parsed.type !== "session_meta" || !parsed.payload || typeof parsed.payload !== "object" || Array.isArray(parsed.payload)) {
+            return { error: "session file does not start with session_meta" };
+        }
+        return { payload: parsed.payload };
+    }
+    catch (error) {
+        return {
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+export function resolveCodexSessionSource(threadId, options) {
+    const codexHome = resolveCodexHome(options?.codexHome);
+    const sessionsDir = path.join(codexHome, "sessions");
+    if (!existsSync(sessionsDir)) {
+        return {
+            threadId,
+            codexHome,
+            sessionsDir,
+            exists: false,
+            error: `sessions directory not found: ${sessionsDir}`,
+        };
+    }
+    const matches = [];
+    walkSessionFiles(sessionsDir, threadId, matches);
+    matches.sort().reverse();
+    let firstError;
+    for (const candidate of matches) {
+        const { payload, error } = readSessionMeta(candidate);
+        if (payload && payload.id === threadId) {
+            return {
+                threadId,
+                codexHome,
+                sessionsDir,
+                exists: true,
+                path: candidate,
+                ...(typeof payload.id === "string" ? { sessionId: payload.id } : {}),
+                ...(typeof payload.timestamp === "string" ? { startedAt: payload.timestamp } : {}),
+                ...(typeof payload.cwd === "string" ? { cwd: payload.cwd } : {}),
+                ...(typeof payload.originator === "string" ? { originator: payload.originator } : {}),
+            };
+        }
+        if (!firstError && error) {
+            firstError = `${candidate}: ${error}`;
+        }
+    }
+    return {
+        threadId,
+        codexHome,
+        sessionsDir,
+        exists: false,
+        ...(firstError ? { error: firstError } : { error: `session file not found for thread ${threadId}` }),
+    };
+}

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.40.0",
   "license": "MIT",
   "type": "module",
   "repository": {